线程之间的通信（thread signal）

线程通信的目的是为了能够让线程之间相互发送信号。另外，线程通信还能够使得线程等待其它线程的信号，比如，线程B可以等待线程A的信号，这个信号可以是线程A已经处理完成的信号。

通过共享对象通信

有一个简单的实现线程之间通信的方式，就是在共享对象的变量中设置信号值。比如线程A在一个同步块中设置一个成员变量hasDataToProcess值为true，而线程B同样在一个同步块中读取这个成员变量。下面例子演示了一个持有信号值的对象，并提供了设置信号值和获取信号值的同步方法：

public class MySignal { private boolean hasDataToProcess; public synchronized void setHasDataToProcess(boolean hasData){ this.hasDataToProcess=hasData; } public synchronized boolean hasDataToProcess(){ return this.hasDataToProcess; } }

ThreadB计算完成会在共享对象中设置信号值：

public class ThreadB extends Thread{ int count; MySignal mySignal; public ThreadB(MySignal mySignal){ this.mySignal=mySignal; } @Override public void run(){ for(int i=0;i<100;i++){ count=count+1; } try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } mySignal.setHasDataToProcess(true); } }

ThreadA在循环中一直检测共享对象的信号值，等待ThreadB计算完成的信号：

public class ThreadA extends Thread{ MySignal mySignal; ThreadB threadB; public ThreadA(MySignal mySignal, ThreadB threadB){ this.mySignal=mySignal; this.threadB=threadB; } @Override public void run(){ while (true){ if(mySignal.hasDataToProcess()){ System.out.println("线程B计算结果为:"+threadB.count); break; } } } public static void main(String[] args) { MySignal mySignal=new MySignal(); ThreadB threadB=new ThreadB(mySignal); ThreadA threadA=new ThreadA(mySignal,threadB); threadB.start(); threadA.start(); } }

很明显，采用共享对象方式通信的线程A和线程B必须持有同一个MySignal对象的引用，这样它们才能彼此检测到对方设置的信号。当然，信号也可存储在共享内存buffer中，它和实例是分开的。

线程的忙等

从上面例子中可以看出，线程A一直在等待数据就绪，或者说线程A一直在等待线程B设置hasDataToProcess的信号值为true：

public void run(){ while (true){ if(mySignal.hasDataToProcess()){ System.out.println("线程B计算结果为:"+threadB.count); break; } } }

为什么说是忙等呢？因为上面代码一直在执行循环，直到hasDataToProcess被设置为true。

忙等意味着线程还处于运行状态，一直在消耗CPU资源，所以，忙等不是一种很好的现象。那么能不能让线程在等待信号时释放CPU资源进入阻塞状态呢？其实java.lang.Object提供的wait()、notify()、notifyAll()方法就可以解决忙等问题。

wait()、notify()、notifyAll()

Java提供了一种内联机制可以让线程在等待信号时进入非运行状态。当一个线程调用任何对象上的wait()方法时便会进入非运行状态，直到另一个线程调用同一个对象上的notify()或notifyAll()方法。

为了能够调用一个对象的wait()、notify()方法，调用线程必须先获得这个对象的锁。因为线程只有在同步块中才会占用对象的锁，所以线程必须在同步块中调用wait()、notify()方法。

我们把上面通过共享对象通信的例子改成调用对象wait()、notify()方法来实现：

首先我们先构造一个任意对象，我们又把它称作监控对象：

public class MonitorObject { }

ThreadD负责计算，在计算完成时唤醒被阻塞的ThreadC:

public class ThreadD extends Thread{ int count; MonitorObject mySignal; public ThreadD(MonitorObject mySignal){ this.mySignal=mySignal; } @Override public void run(){ for(int i=0;i<100;i++){ count=count+1; } try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } synchronized (mySignal){ mySignal.notify();//计算完成调用对象的notify()方法，唤醒因调用这个对象wait()方法而挂起的线程 } } }

ThreadC等待ThreadD的唤醒：

public class ThreadC extends Thread{ MonitorObject mySignal; ThreadD threadD; public ThreadC(MonitorObject mySignal, ThreadD threadD){ this.mySignal=mySignal; this.threadD=threadD; } @Override public void run(){ synchronized (mySignal){ try { mySignal.wait(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("线程B计算结果为:"+threadD.count); } } public static void main(String[] args) { MonitorObject mySignal=new MonitorObject(); ThreadD threadD=new ThreadD(mySignal); ThreadC threadC=new ThreadC(mySignal,threadD); threadC.start(); threadD.start(); } }

在这个例子中，线程C因调用了监控对象的wait()方法而挂起，线程D通过调用监控对象的notify()方法唤醒挂起的线程C。我们还可以看到，两个线程都是在同步块中调用的wait()和notify()方法。如果一个线程在没有获得对象锁的前提下调用了这个对象的wait()或notify()方法，方法调用时将会抛出 IllegalMonitorStateException异常。

注意，当一个线程调用一个对象的notify()方法，则会唤醒正在等待这个对象所有线程中的一个线程（唤醒的线程是随机的），当线程调用的是对象的notifyAll()方法，则会唤醒所有等待这个对象的线程（唤醒的所有线程中哪一个会执行也是不确定的）。

这里还有一个问题，既然调用对象wait()方法的线程需要获得这个对象的锁，那么这会不会阻塞其它线程调用这个对象的notify()方法呢？答案是不会阻塞，当一个线程调用监控对象的wait()方法时，它便会释放掉这个监控对象锁，以便让其它线程能够调用这个对象的notify()方法或者wait()方法。

另外，当一个线程被唤醒时不会立刻退出wait()方法，只有当调用notify()的线程退出它的同步块为止。也就是说，被唤醒的线程只有重新获得监控对象锁时才会退出wait()方法，因为wait()方法在同步块中，它的执行需要再次获得对象锁。所以，当通过notifyAll()方法唤醒被阻塞的线程时，一次只能有一个线程会退出wait()方法，同样是因为每个线程都需要先获得监控对象锁才能执行同步块中的wait()方法退出。

相关资源：线程间通信方式3：消息传递方式