写在前面

一个线程修改了一个对象的值，而另一个线程感知到了变化，然后进行相应的操作，整个过程开始于一个线程，而最终执行又是另一个线程。前者是生产者，后者就是消费者，这种模式隔离了“做什么”（what）和“怎么做”（How），在功能层面上实现了解耦，体系结构上具备了良好的伸缩性，在 Java 语言中如何实现类似的功能呢？

答案：Java 通过内置的等待/通知机制能够很好地解决线程间通信的功能。

等待/通知相关方法

等待/通知的相关方法是任意 Java 对象都具备的，因为这些方法被定义在所有对象的超类 java.lang.Object 上，方法和描述如下表

等待/通知机制，是指一个线程 A 调用了对象 O 的 wait()方法进入等待状态，而另一个线程 B 调用了对象 O 的 notify()或者 notifyAll()方法，线程 A 收到通知后从对象 O 的wait()方法返回，进而执行后续操作。上述两个线程通过对象 O 来完成交互，而对象上的wait()和 notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通知方之间的交互工作。

使用实例与解析

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class WaitNotifyTest {

    static volatile boolean flag = true;
    static Object lock = new Object();

    public static void main(String[] args) throws Exception {
        Thread waitThread = new Thread(new Wait(), "WaitThread");
        waitThread.start();
        TimeUnit.SECONDS.sleep(1);
        Thread notifyThread = new Thread(new Notify(), "NotifyThread");
        notifyThread.start();
    }

    public static String getDate() {
        return new SimpleDateFormat(" HH: mm: ss ").format(new Date());
    }

    static class Wait implements Runnable {
        public void run() {
            // 加锁，拥有 lock 的 Monitor
            synchronized (lock) {
                // 当条件不满足时，继续 wait，同时释放了 lock 的锁
                while (flag) {
                    try {
                        System.out.println(Thread.currentThread() + " flag is true. wa @ " + getDate());
                        lock.wait();
                    } catch (InterruptedException e) {
                    }
                }
                // 条件满足时，完成工作
                System.out.println(Thread.currentThread() + " flag is false. running @ " + getDate());
            }
        }
    }

    static class Notify implements Runnable {
        public void run() {
            // 加锁，拥有 lock 的 Monitor
            synchronized (lock) {
                // 获取 lock 的锁，然后进行通知，通知时不会释放 lock 的锁，
                // 直到当前线程释放了 lock 后，WaitThread 才能从 wait 方法中返回
                System.out.println(Thread.currentThread() + " hold lock. notify @ " + getDate());
                lock.notifyAll();
                flag = false;
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 再次加锁
            synchronized (lock) {
                System.out.println(Thread.currentThread() + " hold lock again. sleep @ " + getDate());
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

执行结果：

Thread[WaitThread,5,main] flag is true. wa @  15: 59: 53 
Thread[NotifyThread,5,main] hold lock. notify @  15: 59: 54 
Thread[WaitThread,5,main] flag is false. running @  15: 59: 59 
Thread[NotifyThread,5,main] hold lock again. sleep @  15: 59: 59 
1
2
3
4

上述例子主要说明了调用 wait()、notify()以及 notifyAll()时需要注意的细节，如下：

1. 使用 wait()、notify()和 notifyAll()时需要先对调用对象加锁。
2. 调用 wait()方法后，线程状态由 RUNNING 变为 WAITING，并将当前线程放置到对象的等待队列。
3. notify()或 notifyAll()方法调用后，等待线程依旧不会从 wait()返回，需要调用notify()或 notifAll()的线程释放锁之后，等待线程才有机会从 wait()返回。
4. notify()方法将等待队列中的一个等待线程从等待队列中移到同步队列中，而notifyAll() 方法则是将等待队列中所有的线程全部移到同步队列，被移动的线程状态由 WAITING 变为 BLOCKED。
5. 从 wait()方法返回的前提是获得了调用对象的锁。

从上述细节中可以看到，等待/通知机制依托于同步机制，其目的就是确保等待线程 从 wait()方法返回时能够感知到通知线程对变量做出的修改。

以下是该实例的执行过程

WaitThread 首先获取了对象的锁，然后调用对象的 wait()方法，从而放弃了锁并进入了对象的等待队列 WaitQueue 中，进入等待状态。由于 WaitThread 释放了对象的锁， NotifyThread 随后获取了对象的锁，并调用对象的 notify()方法，将WaitThread 从 WaitQueue 移到 SynchronizedQueue 中，此时 WaitThread 的状态变为阻塞状态。NotifyThread 释放了锁之后， WaitThread 再次获取到锁并从 wait()方法返回继续执行。

等待/通知的经典范式

等待/通知的经典范式分为两部分，分别针对等待方（消费者）和通知方（生产者）。

等待方遵循如下原则：

1. 获取对象的锁。
2. 如果条件不满足，那么调用对象的 wait()方法，被通知后仍要检查条件。
3. 条件满足则执行对应的逻辑。
   对应的伪代码如下：

synchronized(对象) {
	while(条件不满足) { 
		对象.wait();
	}
	对应的处理逻辑
}
1
2
3
4
5
6

通知方遵循如下原则：

1. 获得对象的锁。
2. 改变条件。
3. 通知所有等待在对象上的线程。
   对应的伪代码如下：

synchronized(对象){
 	改变条件
 	对象.notifyAll();
}
1
2
3
4