线程基础（第二部分）Java线程的缺陷和副作用几解决办法

Al Saganich / 翻译：朱英

<--在线程基础的第二部分中，我们将了解一下使用Java线程的缺陷和副作用，以及在SUN JDK 1.2中是如何修改线程的运行机制的-->

在上篇文章《Java 101之线程基础》中，我们介绍了线程的概念以及如何使用线程。这个月，我们将转到更高级的话题，包括线程的缺陷及副作用，以及在SUN JDK 1.2中，是如何改进线程的运行机制的。

synchronize（同步）
让我们回忆一下上篇文章中讲的：线程允许两个或者更多个进程同时执行。实际上，这些线程也可以共享对象和数据，在这种情形下，你要知道不同的线程在同一时间内不能存取同一数据，因为一开始设计Java的时候，就采用了线程的概念，Java语言定义了一个特殊的关键字synchronize（同步），该关键字可以应用到代码块上，代码块也包括入口方法，该关键字的目的是防止多个线程在同一时间执行同一代码块内的代码。

定义一个同步的方法，格式如下：

[public|private] synchronized {type}
methodname(...)
一个把同步这个关键字应用到方法中的简单的例子：

public class someClass {
public void aMethod() {
// Some code
synchronized(this) {
// Synchronized code block
}
// more code.
}
}
同步化的关键字可以保证在同一时间内只有一个线程可以执行该代码段，而任何其他要用到该段代码的线程将被阻塞，直到第一个线程执行完该段代码。

死锁和饥饿
对于饥饿的定义-由于别的并发的激活的过程持久占有所需资源，是莫个异步过程载客预测的时间内不能被激活。

最常遇到的线程的两个缺陷是死锁和饥饿。当一个或者多个进程，在一个给定的任务中，协同作用，互相干涉，而导致一个或者更多进程永远等待下去，死锁就发生了。与此类似，它当一个进程永久性地占有资源，使得其他进程得不到该资源，就发生了饥饿。

首先我们看一下死锁问题。考虑一个简单的例子，假如你到ATM机上取钱，但是你却看到如下的信息“现在有没有现金，请等会儿再试。”你需要钱，所以你就等了一会儿再试，但是你又看到同样的信息。与此同时，在你后面，一辆运款装甲车正等待着把钱放进ATM中，但是运款装甲车到不了ATM取款机，因为你的汽车挡着道。而你又要取到钱，才会离开原地。这种情况下，就发生了死锁。

在饥饿的情形下，系统不处于死锁状态中，因为有一个进程仍在处理之中，只是其他进程永远得不到执行的机会。在什么样的环境下，会导致饥饿的发生，没有预先确定好的规则。而一旦发生下面四种情况之一，就会导致死锁的发生。

相互排斥: 一个线程或者进程永远占有一共享资源，例如，独占该资源。
循环等待: 进程A等待进程B，而后者又在等待进程C，而进程C又在等待进程A。
部分分配: 资源被部分分配。例如，进程A和B都需要用访问一个文件，并且都要用到打印机，进程A获得了文件资源，进程B获得了打印机资源，但是两个进程不能获得全部的资源。
缺少优先权: 一个进程访问了某个资源，但是一直不释放该资源，即使该进程处于阻塞状态。
如果上面四种情形都不出现，系统就不会发生死锁。请再看一下刚才的文件/打印机的例子，当其中一个进程判断出它得不到它所需要的第二个资源，就释放已经得到的第一个资源，那么第二个教程可以获得两个资源，并能够运行下去。

线程的高级用法
到目前为止，我们已经谈到创建和管理线程的基本知识。你需要做的就是启动一个线程，并让它运行。你的应用程序也许希望等待一个线程执行完毕，也许打算发送一个信息给线程，或者只打算让线程在处理之前休眠一会儿。线程类提供了四种对线程进行操作的API调用。

Join

如果一个应用程序需要执行很多时间，比如一个耗时很长的计算工作，你可以把该计算工作设计成线程。但是，假定还有另外一个线程需要计算结果，当计算结果出来后，如何让那个线程知道计算结果呢？解决该问题的一个方法是让第二个线程一直不停地检查一些变量的状态，直到这些变量的状态发生改变。这样的方式在UNIX风格的服务器中常常用到。Java提供了一个更加简单的机制，即线程类中的join 方法。

join 方法使得一个线程等待另外一个线程的结束。例如，一个GUI (或者其他线程)使用join方法等待一个子线程执行完毕：

CompleteCalcThread t = new
CompleteCalcThread();
t.start();
//
// 做一会儿其他的事情
// 然后等待
t.join();
// 使用计算结果...
你可以看到，用对子线程使用join方法，等待子线程执行完毕。 Join 有三种格式：

void join(): 等待线程执行完毕。
void join(long timeout): 最多等待某段时间让线程完成。
void join(long milliseconds， int nanoseconds): 最多等待某段时间（毫秒＋纳秒），让线程完成。
线程API isAlive同join相关联时，是很有用的。一个线程在start(此时run方法已经启动)之后，在stop之前的某时刻处于isAlive 状态。

对于编写线程的程序员来说，还有其他两个有用的线程API，即wait和 notify。使用这两个API，我们可以精确地控制线程的执行过程。考虑一个简单的例子，有个生产者线程和消费者线程，为了让应用程序更有效率，所以我们不打算采用查询等待的方法。当消费者可以消费对象时，消费者需要得知该信息。

我们可以把该例子阐述如下：生产者线程不断地在运行着，把项目放入列表中，该列表的add方法由synchronize 关键字保护着，当一个对象添加到列表中，生产者就可以通知消费者：它已经添加一个对象，消费者可以消费该对象了。每个对象的run方法的伪代码请见表A。

表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的推出，开发者们将被迫对其编写的线程对系统和其他进程的作用过程考虑得更加周到。最终，对于线程及其相关知识的正确理解，将会有助于聪明的开发者设计出更加健壮的应用程序。

原文转自：http://www.ltesting.net