作者: Al Saganich

<让我们深入了解一下Java线程，以及了解一下为什么需要需要开发基于线程的应用程序>

线程是Java语言的一个部分，而且是Java的最强大的功能之一。究竟什么是线程，为什么要开发基于线程的应用程序？在本文中，我们将深入了解一下线程的用法，以及使用线程的一些技术。在我们开始讲述线程之前，最好先了解一下有关背景知识和分析一下线程的工作原理。

当程序员一开始开发应用程序时，这些应用程序只能在一个时间内完成一件事情。应用程序从主程序开始执行，直到运行结束，像 Fortran/Cobol/Basic这些语言均是如此。

随着时间的推移，计算机发展到可以在同一时间段内运行不止一个应用程序的时代了，但是应用程序运行时仍然是串行的，即从开始运行到结束，下一条指令接着上一条指令执行。到最近，程序发展到可以在执行时，以若干个线程的形式运行。Java就具有运行多线程的能力，可以在同一时间段内进行几个操作，这就意味着给定的操作不必等到另外一个操作结束之后，才能开始。而且对某个操作可以指定更高一级的优先级。

不少程序语言，包括ADA， Modula-2和C/C++，已经可以提供对线程的支持。同这些语言相比，Java的特点是从最底层开始就对线程提供支持。除此以外，标准的Java类是可重入的，允许在一个给定的应用程序中由多个线程调用同一方法，而线程彼此之间又互不干扰。Java的这些特点为多线程应用程序的设计奠定了基础。

什么是线程?

究竟什么是线程呢？正如在图A中所示，一个线程是给定的指令的序列 (你所编写的代码)，一个栈(在给定的方法中定义的变量)，以及一些共享数据(类一级的变量)。线程也可以从全局类中访问静态数据。

栈以及可能的一些共享数据

每个线程有其自己的堆栈和程序计数器（PC）。你可以把程序计数器（PC）设想为用于跟踪线程正在执行的指令，而堆栈用于跟踪线程的上下文，上下文是当线程执行到某处时，当前的局部变量的值。虽然你可以编写出在线程之间传送数据的子程序，在正常情况下，一个线程不能访问另外一个线程的栈变量。

一个线程必须处于如下四种可能的状态之一，这四种状态为：

• 初始态：一个线程调用了new方法之后，并在调用start方法之前的所处状态。在初始态中，可以调用start和stop方法。
• Runnable：一旦线程调用了start 方法，线程就转到Runnable 状态，注意，如果线程处于Runnable状态，它也有可能不在运行，这是因为还有优先级和调度问题。 阻塞/ NonRunnable：线程处于阻塞/NonRunnable状态，这是由两种可能性造成的：要么是因挂起而暂停的，要么是由于某些原因而阻塞的，例如包括等待IO请求的完成。 退出：线程转到退出状态，这有两种可能性，要么是run方法执行结束，要么是调用了stop方法。
• 最后一个概念就是线程的优先级，线程可以设定优先级，高优先级的线程可以安排在低优先级线程之前完成。一个应用程序可以通过使用线程中的方法setPriority(int)，来设置线程的优先级大小。

前面我们已经讲述了线程的基本知识，现在我们可以来看看Java为我们提供的用来开发基于线程的应用程序的两种机制：线程类和Runnable 接口。

派生线程类

最简单的编写基于线程的代码的方法之一，就是派生java.lang.Thread 类。该线程类是java.lang 包的一个成员，在缺省情况下，线程类可以被所有的Java应用程序调用。为了使用线程类，我们需要了解The java.lang.Thread 类中定义的五个方法：

• run()：该方法用于线程的执行。你需要重载该方法，以便让线程做特定的工作。
• start()：该方法使得线程启动run()。
• stop()：该方法同start方法的作用相反，停止线程的运行。
• suspend()：该方法同stop方法不同的是，它并不终止未完成的线程，它仅仅挂起线程，以后还可恢复。
• resume()：该方法重新启动已经挂起的线程。

运行List A中的程序，运行结果见List B

List A ：扩展线程类

class TestThreads {  public static void main (String args []) {     class MyThread extends Thread {        String which;        MyThread (String which) {        this.which = which;      }     public void run() {        int iterations = (int)(Math.random()*100) %15;        int sleepinterval = (int)(Math.random()*1000);        System.out.println(which + " running for " + iterations +" iterations");        System.out.println(which + " sleeping for " + sleepinterval + "ms between loops");        for (int i = 0; < iterations; i++) {           System.out.println(which +" " + i);                   try {                       Thread.sleep(sleepinterval);                   } catch (InterruptedException e) {}               }           }       }       MyThread a = new MyThread("Thread A");       MyThread b = new MyThread("Thread B");       MyThread c = new MyThread("Thread C");       a.start();       b.start();       c.start();   }}

ListB: 清单A的输出

Thread A running for 16 iterations Thread C running for 15 iterations Thread B running for 14 iterations Thread A sleeping for 305ms between    loops Thread C sleeping for 836ms between    loops Thread B sleeping for 195ms between    loops Thread A 0 Thread C 0 Thread B 0 . . . Thread C 13 Thread B 13 Thread A 14 Thread C 14 Thread A 15

List A演示了如何从现有的Thread类中派生出一个新类。新创建的类重载了run 方法。有趣的是，实现run 方法不必很严格，因为Thread类提供一个缺省的run方法，尽管它不是特别有用。

在有些场合，我们不能简单地改变指定对象的父类。我们仍然需要采用线程。这时，我们就需要用到Runnable接口。

使用Runnable接口

开发线程应用程序的第二个方法是通过Runnable接口来实现。在不少场合，你不能重新定义类的父母，或者不能定义派生的线程类，也许你的类的层次要求你的父类为特定的类。在这些情况下，可以通过Runnable接口来实现多线程的功能。

提示：接口是个复杂的技术，要彻底理解它的用法需要花费力气。感兴趣的读者可以阅读我的前一篇文章《接口的阐述》，发表在1998年5月的 Visual J++ Developer's Journal杂志上。

List C是一个简单的动画小程序，它是一个使用Runnable接口的例子。该例子可以放在网页上，它需要从Applet类中派生出来。该小程序的目的是通过对一个接一个的图象进行着色，从而显示出动画的效果。因为动画占用了不少处理器时间，我们不打算在图象着色的时候阻塞其他进程的运行。例如，如果打算停止动画，我们不想等到它运行结束时，再调用stop方法。换句话说，我们可以让小程序线程化。

List C: 动画小程序

import java.applet.*;import java.awt.*;public class TstRunnable extends Applet    implements Runnable {  private Thread m_Thread = null;  private Image m_Images[];  private Image m_CurrentImage =null;  private int m_nImgWidth = 0;  private int m_nImgHeight = 0;  private boolean m_fAllLoaded =  alse;  private final int NUM_IMAGES = 18;  public TstRunnable() { }  private void displayImage(Graphics g) {     if ( null != m_CurrentImage )        g.drawImage(m_CurrentImage,(getSize().width - m_nImgWidth) / 2,            (getSize().height - m_nImgHeight) / 2, null);  }  public void paint(Graphics g) {     if (null != m_CurrentImage) {        Rectangle r = g.getClipBounds();        g.clearRect(r.x, r.y, r.width, r.height);        displayImage(g);    }     else        g.drawString("Loading images...", 10, 20);  }// The Applets start method is called when the page is first shown.  public void start() {     if (m_Thread == null) {        m_Thread = new Thread(this);        m_Thread.start();     } }// The Applets stop method is called when the page is hidden.  public void stop() {     if (m_Thread != null) {        m_Thread.stop();        m_Thread = null;     }  }// The run method is used by the thread//   object we created in this start method.  public void run() {     int iWhichImage = 0;     Graphics m_Graphics = getGraphics();     repaint();     m_Graphics = getGraphics();     m_Images   = newImage[NUM_IMAGES];     MediaTracker tracker = new MediaTracker(this);     String strImage;     for (int i = 1; i <= NUM_IMAGES; i++) {        m_Images[i-1] = getImage(getCodeBase(),            "img" + new Integer(i).toString() + ".gif");        tracker.addImage(m_Images[i-1],0);     }     try {        tracker.waitForAll();        m_fAllLoaded = !tracker.isErrorAny();     } catch (InterruptedException e) {}     if (!m_fAllLoaded) {        stop();        m_Graphics.drawString("Error loading images!", 10, 40);        return;     } // Assuming all images are the same // width and height. //------------------------------------     m_nImgWidth  = m_Images[0].getWidth(this);     m_nImgHeight = m_Images[0].getHeight(this);     repaint();     while (true) {        try {// Draw next image in animation.           m_CurrentImage = m_Images[iWhichImage];           displayImage(m_Graphics);           iWhichImage = (iWhichImage+1) % NUM_IMAGES;           Thread.sleep(50);        } catch (InterruptedException e) {           stop();        }     } }}

我们使用Runnable接口实现了线程，而没有通过创建线程类的派生类的方式。使用Runnable接口，需要我们实现run方法。我们也需要创建Thread对象的一个实例，它最终是用来调用run方法的。在小程序中的start方法中，我们通过使用thread建构方法产生一个Thread对象的实例，其参数就是实现Runnable接口的任何类。 Thread 对象启动已经定义好的run 方法，而run方法是用来进行动画显示的。当然，从线程类中派生出一个类，并在Applet派生类中创建实例，我们可完成同样的事情。该例子是用来演示Runnable接口的用法。

在我们接着读下去之前，有几个问题需要回答。你也许会问，浏览器调用Java小程序的start和stop方法吗? run 方法是如何被调用的? 情况是这样的，当浏览器启动了一个内部线程时，就相应地启动了applet 的运行。当网页显示时，就启动了applet的start 方法。Start方法创建一个线程对象，并把applet自身传送给线程，以实现run方法。

此时，两个线程在运行：由浏览器启动的初始线程，以及处理动画的线程。快速查看applet的start方法，可以知道它创建了线程，并启动了它。类似地，当网页被隐藏后，applet的stop方法就调用了线程的stop方法。

注意：在Applets和Threads中的 start/stop子程序

在Applet 和Thread 两个类中都有start和stop方法，但它们的功能不同。一旦Applet 显示时，就调用applet的start方法，一旦applet 隐藏时，就调用applet的stop 方法。相反，线程的start方法将调用run方法，线程的stop方法将停止正在执行的线程。

动画程序的设计原理

既然我们已经看过动画是如何开始的。现在看看它的机理。首先，我们通过定义Runnable 接口的方式来编写小程序，一旦定义了该接口，就表明我们将在其后实现run方法。

public class TstRunnable  extends Applet implements Runnable . . 

然后我们编写run方法，该方法将被动画线程所调用。

public void run() {  . . .   }

我们也需要一个线程对象，该对象将管理我们的动画线程，如：

private Thread m_Thread = null;

一旦做好这些准备工作以后，当applet第一次被显示时，就会创建线程对象的一个实例，并把this对象作为建构方法的参数，之后就可以启动动画了：

public void start() {  if (m_Thread == null)      {     m_Thread      = new Thread(this);     m_Thread.start();  }}

最后一步编写如下代码：一旦applet 被隐藏时，就停止动画，Applet的stop方法如下：

public void stop(){  if (m_Thread != null) {     m_Thread.stop();     m_Thread = null;  }}

结论

基于线程的程序功能强大。本文中，我们讨论了线程的一些基本知识：什么是线程，如何使用它们。下个月，我们将学习一些使用线程时的注意点，并讨论线程的一些高级用法。