1. 基本概念

在业务处理过程中，线程间常常需要进行通信，从而协同完成某个事项。比如，有两个线程A和B，线程A负责读取数据，线程B负责处理数据，线程A在读取完数据后必须通知线程B进行数据处理，这个“通知”就是线程通信的表现。

2. 忙等待

怎样实现线程通信呢？可以通过在线程间访问一个共同的资源（标志位）来实现。比如线程A和线程B，线程A负责读取数据，线程B负责处理数据。我们在A和B之间设置一个共同的资源：布尔值的Flag，标记A有没有读取完数据（默认为false，表示未读取完数据）。我们让B一直监听着这个Flag标记（使用while循环），当A读取完数据后，会将这个Flag设为true，这时B监听到Flag变为true了，就可以进行数据处理操作了。
简要代码如下：

public class SignalBusyWait {

    private volatile static Boolean flag = false;//共享资源，设置标志位
    public static void main(String[] args) {
        
        Thread A = new Thread(new Runnable() {//线程A，负责读取数据，读取完设置flag为true
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    System.out.println("读取数据");
                    Thread.sleep(2000);
                    flag = true;
                    
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                
            }
        },"Thread A");
        
        Thread B = new Thread(new Runnable() {//线程B，负责处理数据，死循环监听flag
            @Override
            public void run() {
                // TODO Auto-generated method stub
                while(true){
                    if(flag){
                        System.out.println("处理数据");
                        break;//处理完数据，退出死循环
                    }else{
                        System.out.println("flag 为false，表示数据未读取完，B线程进行等待");
                    }
                }
                
            }
        },"Thread B");
        B.start();
        A.start();
    }
}

以上方式虽然能够实现线程通信，但是B线程不断地监听标志位，一直处理“等待”状态，这就是忙等待现象。那么如何处理忙等待现象呢？Java提供了notify和wait机制。

3. notify，wait和notifyAll

Java给所有的对象都内置了三个方法，用于线程通信。分别是notify，wait和notifyAll（这三个方法都是Object类的方法，Object类是所有Java类的父类，等于说所有Java对象都拥有了这三个方法）。

• 同一把锁 : notify和wait方法必须使用同一监听对象（即竞争同一把锁）。
• 就绪队列和等待队列：同一个监听对象上有两个队列，分别是就绪队列和等待队列。当线程不满足执行条件时（比如负责处理数据的B线程得到锁后，发现数据还没有读取完，无法进行处理），就会进入等待队列，等待执行条件满足时被唤醒。当线程被唤醒后并不是马上执行，而是进入就绪队列，随时准备好竞争锁，获得锁后才能真正执行。
• wait：当线程获得锁后发现执行条件不满足，这时候会调用wait方法，将这个线程加入到等待队列中，并释放锁，让其他就绪的线程可以再次竞争锁。
• notify：当线程中调用notify方法时，当前线程并不会获放锁，当前线程会继续执行下去。它做的只是唤醒“等待队列”中的一个线程，可以进入“就绪队列”了。
• notifyAll: 与notify相同，只是它唤醒的是整个等待队列中的所有线程。
  上面的代码利用wait和notify实现如下：

public class NotifyWait {

    public final static Object monitorObject = new Object();//监听对象
    public static void main(String[] args) {
        
        Thread A = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized(monitorObject){
                    try {
                        Thread.sleep(2000);
                        System.out.println("读取数据");
                        monitorObject.notify();//读取完数据，通知线程B处理数据
                        
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
            }
        },"Thread A");
                
        Thread B = new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                synchronized(monitorObject){
                    try {
                        System.out.println("B线程获得锁，但发现数据未读取完，进行等待");
                        monitorObject.wait();
                        Thread.sleep(2000);
                        System.out.println("处理数据");
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    
                }
            }
        },"Thread B");
        
        B.start();
        A.start();
        
    }
}

4. 使用wait和notify需要注意的问题

4.1 必须与synchronized关键字联用

使用wait和notify进行通信时，必须与synchronized关键字结合使用，即必须在synchronized块中调用wait和notify方法，才能够保证同一时间只有一个线程发送信号。

4.2 信号丢失问题

有一种情况，当对象调用notify方法时，等待队列中没有线程，则没有任何线程会收到这个信号，之后调用wait方法的线程将会一直等待，因为唤醒它的信号已经丢失了。怎么办呢，我们可以定义一个成员变量用来保存信号的状态，然后在调用notify方法和wait方法前得到这个成员变量的值，判断信号是否已经发出，如以下代码所示：

public class MyWaitNotify2{

  MonitorObject myMonitorObject = new MonitorObject();
  boolean wasSignalled = false;

  public void doWait(){
    synchronized(myMonitorObject){
      if(!wasSignalled){
        try{
          myMonitorObject.wait();
         } catch(InterruptedException e){...}
      }
      //clear signal and continue running.
      wasSignalled = false;
    }
  }

  public void doNotify(){
    synchronized(myMonitorObject){
      wasSignalled = true;
      myMonitorObject.notify();
    }
  }
}

我们定义了wasSingalled成员变量用来标示信号是否发出，这从一定程度上保证了信号不会丢失。

4.3 伪唤醒问题

上例中，有时候用于标示信号是否发出的标志位在监听对象并未调用notify方法时，就被修改成了true，从而导致本不该唤醒的进程被唤醒，唤醒的线程会继续执行后面的代码，也就是所谓伪唤醒问题。我们可以将对标志位的判断由if改为while，让被唤醒的线程再判断一次标志位，确定是否唤醒了正确的线程，从而避免伪唤醒问题。

4.4 不能使用字符串常量作为监听对象

注意，不能使用字符串常量作为监听对象，因为在JVM中是将字符串常量编译到同一个对象的。举个例子，当有两个对象A和B都使用字符串常量（无论是否同一常量）作为监听对象，当对象A调用notify方法时，它可能会唤醒对象B等待队列中的线程，从而造成混乱。