作者: 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;
}
}
结论
基于线程的程序功能强大。本文中，我们讨论了线程的一些基本知识：什么是线程，如何使用它们。下个月，我们将学习一些使用线程时的注意点，并讨论线程的一些高级用法。
