线程通信的目的是为了能够让线程之间相互发送信号。另外，线程通信还能够使得线程等待其它线程的信号，比如，线程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()方法退出。