【java高性能编程基础】 – jdk提供的三对线程通信的等待/通知机制api
文章目录
前言
想要实现对个线程之间的协同（如：线程的执行顺序），就涉及到线程之间的通信。线程通信有许多种方式，比如，共享变量、消息队列、文件共享等等。
下面，我们就一起来看看JDK api中提供的一种线程通信的方式——等待/通知机制。
jdk提供了三种实现线程通信的等待/通知机制：
- suspend / resume
- wait / notify
- park / unpark
生产者与消费者模式是一个典型的多线程并发协作的模式，在这个模式中，一部分线程被用于去生产数据，另一部分线程去处理数据。下面就是用等待/通知机制来实现生产者消费者模式。
注意：在下面的例子中，主线程充当生产者，new Thread()的线程充当消费者的角色。
1. suspend / resume
调用suspend挂起目标线程，通过resume可以恢复线程执行。
正常执行
/** 临界资源 */
public static Object resource = null;
public void suspendResumeTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (resource == null) { // 如果没有可用的临界资源，则进入等待
System.out.println(new Date() + " 进入等待............");
Thread.currentThread().suspend();
}
System.out.println("获取到临界资源，开始运行");
});
consumerThread.start();
// 3秒之后，生产一个资源
Thread.sleep(3000L);
resource = new Object();
System.out.println(new Date() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
consumerThread.resume();
}
然而，suspend / resume这种等待/通知方式已经被弃用了，因为它非常容易写出死锁，表现在两个方面：
- suspend不会自动释放锁，从而导致死锁；
- 如果suspend 和 resume 的执行顺序搞反了就会导致程序永久挂起，从而形成死锁。
出现死锁
下面举例说明两种死锁的形成：
- suspend不会自动释放锁
/** 临界资源 */
public static Object resource = null;
public void suspendResumeDeadLockTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (resource == null) { // 如果没有可用的临界资源，则进入等待
System.out.println(new Date() + " 进入等待............");
// 当前线程拿到锁，然后挂起
synchronized (this) {
Thread.currentThread().suspend();
}
}
System.out.println("获取到临界资源，开始运行");
});
consumerThread.start();
// 3秒之后，生产一个资源
Thread.sleep(3000L);
System.out.println(new Date());
resource = new Object();
// 争取到锁以后，再恢复consumerThread
synchronized (this) {
consumerThread.resume();
}
System.out.println(new Date() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
}
运行程序，发现程序被卡住了，线程一直被挂起，发生死锁。
- suspend 和 resume 的执行顺序不对
/** 临界资源 */
public static Object resource = null;
public void suspendResumeDeadLockTest2() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (resource == null) {
System.out.println(new Date() + " 进入等待............");
try { // 为这个线程加上一点延时
Thread.sleep(5000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 这里的挂起执行在resume后面
Thread.currentThread().suspend();
}
System.out.println("获取到临界资源，开始运行");
});
consumerThread.start();
// 3秒之后，生产一个临界资源
Thread.sleep(3000L);
System.out.println(new Date());
resource = new Object();
consumerThread.resume();
System.out.println(new Date() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
consumerThread.join();
}
suspend 和 resume 的执行顺序搞反了就会导致程序永久挂起，从而形成死锁。
已经生产了临界资源被通知消费者线程，但程序一起挂起不再运行。
2. wait / notify
wait / notify 是 suspend / resume机制的一个替代机制。
wait方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁，也就是wait方法会自动释放锁，这样就减小了写出死锁的可能性。
wait / notify方法只能由同一对象锁的持有者线程调用，也就是写在同步块里面，否则会抛出lllegalMonitorStateException异常。
正常执行
/** 临界资源 */
public static Object resource = null;
public void waitNotifyTest() throws Exception {
// 启动线程
new Thread(() -> {
if (resource == null) { // 如果没有可用的临界资源，则进入等待
synchronized (this) {
try {
System.out.println(new Date() + " 进入等待............");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("获取到临界资源，开始运行");
}).start();
// 3秒之后，生产一个临界资源
Thread.sleep(3000L);
resource = new Object();
synchronized (this) {
this.notifyAll();
System.out.println(new Date() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
}
}
出现死锁
虽然wait会自动解锁，但是对顺序有要求，如果在notify被调用之后，才开始wait方法的调用，线程会永远处于WAITING状态。
public void waitNotifyDeadLockTest() throws Exception {
// 启动线程
new Thread(() -> {
if (resource == null) { // 如果没有可用的临界资源，则进入等待
try {
Thread.sleep(5000L);
} catch (InterruptedException e1) {
e1.printStackTrace();
}
synchronized (this) {
try {
System.out.println(new Date() + " 进入等待............");
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println("获取到临界资源，开始运行");
}).start();
// 3秒之后，生产一个临界资源
Thread.sleep(3000L);
System.out.println(new Date());
resource = new Object();
synchronized (this) {
this.notifyAll();
System.out.println(" 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
}
}
3. park / unpark
线程调用park则等待“许可”,unpark方法为指定线程提供“许可(permit)”。
不要求park和unpark方法的调用顺序。
多次调用unpark之后，再调用park，线程会直接运行。但不会叠加，也就是说，连续多次调用park方法，第一次会拿到“许可”直接运行，后续调用会进入等待。
正常执行
public void parkUnparkTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (resource == null) { // 如果没有可用的临界资源，则进入等待
System.out.println(new Date() + " 进入等待............");
LockSupport.park();
}
System.out.println("获取到临界资源，开始运行");
});
consumerThread.start();
// 3秒之后，生产一个临界资源
Thread.sleep(3000L);
resource = new Object();
System.out.println(new Date() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
LockSupport.unpark(consumerThread);
}
出现死锁
park并不会释放锁，所有再同步代码中使用可能会出现死锁
public void parkUnparkDeadLockTest() throws Exception {
// 启动线程
Thread consumerThread = new Thread(() -> {
if (resource == null) { // 如果没有可用的临界资源，则进入等待
System.out.println(new Date() + " 进入等待............");
// 当前线程拿到锁，然后挂起
synchronized (this) {
LockSupport.park();
}
}
System.out.println("获取到临界资源，开始运行");
});
consumerThread.start();
// 3秒之后，生产一个临界资源
Thread.sleep(3000L);
System.out.println(new Date());
resource = new Object();
// 争取到锁以后，再恢复consumerThread
synchronized (this) {
LockSupport.unpark(consumerThread);
}
System.out.println(new Date() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
}
三种等待/通知机制的比较
| suspend / resume | wait / notify | park/unpark |
|---|---|---|
| 已弃用 | - | - |
| suspend不释放锁 | wait释放锁 | park不释放锁 |
| 要求suspend / resume执行顺序 | 要求wait / notify执行顺序 | 不要求park/unpark执行顺序 |