表A: 演示高级线程方法的伪代码

class ProdCons {
class List {
public synchronized boolean add(Object o)
{...}
public synchronized boleanremove (Object o)
{...}
}
List data = new List();
ProdThread producer = null;
ConsThread consumer = null;
ProdCons() {
producer = new ProdThread(this);
consumer = new ConsThread(this);
producer.start();
consumer.start();
}
}
消费者和生产者的类，请见表B和表C。

表B: Class ConsThread

class ConsThread extends Thread {
ProdCons parent;
ConsThread(ProdCons parent) {
this.parent = parent;
}
public synchronized void canConsume() {
notify();
}
public void run() {
boolean consumed;
do {
synchronized(this) {
try { wait();}
catch (Exception e) { ; }
}
do {
String str = (String)parent.list.remove();
if ( null == str) {
consumed = false;
break;
}
consumed = true;
System.out.println("Consumer
=>consumed " + str);
}
while ( true );
}
while (consumed);
}
}
表C: Class ProdThread

class ProdThread extends Thread {
ProdCons parent;
ProdThread(ProdCons parent) {
this.parent = parent;
}
public void run() {
for ( int i = 0; i < 10; i++) {
String str = new String("ImAString" + i);
System.out.println("Producer produced " + str);
parent.list.add(str);
parent.consumer.canConsume();
}
parent.consumer.canConsume();
}
}
注意：notify和wait两个API都必须位于同步化（synchronized）的方法中或者代码块中！

线程和Sun JDK 1.2
线程提供了一项很有价值的服务，极大地增强了Java程序设计语言的功能。然而，目前的线程实现的确存在一些问题。这些问题的存在，使得Sun JDK 1.2中线程的stop， suspend和resume方法导致人们的批评。

如果我们回到上面的生产者/消费者例子，我们就可以更好地理解这个问题。首先，我们看看死锁。当运行一个applet小程序时，在通常的情况下，两个线程运行时，相安无事，但是，但用户点击到另外一个网页时，问题出现了。如果生产者正在添加一个项目到列表中，最坏的情况就是消费者线程被阻塞。假定，小程序正在创建一个对象，此时突然被挂起（suspended），其他的小程序就不能再对该数据进行更新。尽管出现这样的机会不多，它们的确存在，有时会引起问题。

线程的第二个问题有关不一致的问题。再来看一下生产者/消费者的例子，不难想象，如果生产者线程在添加项目的过程中遇到被中止的情况，可能会造成列表状态不一致。如果我们全面检查现有的Java小程序的个数，就不难发现问题所在。

处理这个不一致的问题的最简单的方法就是派生一个新的线程类，该线程类具有如下功能：通过一个方法的调用可以改变其状态。表D就定义了这样的一个类。MyThread类可以被挂起和重新执行，而无需担心MyThread类的资源会崩溃。MyThread类中的方法 changeState用于暗示应该暂停，停止或者重新执行线程，而不同于以往的停止或者暂停线程。可以向线程发出请求，要求线程在合适的时候处理该请求，而不是强制处理该请求，因而无需向线程发出停止命令。

表D: Class MyThread

public class MyThread extends Thread {
//States the thread can be in.
static final int STATE_RUNNING = 0;
static final int STATE_STOP = 1;
static final int STATE_SUSPEND = 2;
private int currentState = STATE_RUNNING;
// The public method changeState allows
// another process to poke at that hread
// and tell it to do something when it
// next gets a chance.
public final synchronized void
changeState(int newState) {
currentState = newState;
if (STATE_RUNNING == currentState)
notify();
// Must have been suspended.
}
private synchronized boolean currentState() {
// If we where asked to suspend,
// just hang out until we are
// asked to either run or stop.
while ( STATE_SUSPEND == currentState) {
try{ wait(); }
catch (Exception e) {};
}
if ( STATE_STOP == currentState )
return false;
else
return true;
}
public void run() {
do {
if (currentState() == false)
return; // Done
// Perform some work
} while (true);
}
}


MyThread类的用户可以重载run方法，然而，用户需要检查是否有另外的类请求线程改变状态。在JDK 1.2 中对线程的运行机制所做的改变，是问题的症结所在，线程在运行时是否出现不一致，在线程关闭后，是否放弃所占用的资源，线程的运行是否正常，这些工作都是要开发者自己来确保完成了。

结论
线程功能强大而使用复杂。每位Java开发者可以在很多应用场合用到线程。本文中，我们检查了线程的一些副作用，以及线程的一些高级用法。随着Sun JDK 1.2的推出，开发者们将被迫对其编写的线程对系统和其他进程的作用过程考虑得更加周到。最终，对于线程及其相关知识的正确理解，将会有助于聪明的开发者设计出更加健壮的应用程序。