@[TOC]

前言

想要实现对个线程之间的协同（如：线程的执行顺序），就涉及到线程之间的通信。线程通信有许多种方式，比如，共享变量、消息队列、文件共享等等。

下面，我们就一起来看看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 的执行顺序搞反了就会导致程序永久挂起，从而形成死锁。

出现死锁

下面举例说明两种死锁的形成：

1. 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() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
    }

运行程序，发现程序被卡住了，线程一直被挂起，发生死锁。

2. 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() + " 等待三秒生产了一个临界资源，通知消费者>>>>>>>>>>>>");
    }

三种等待/通知机制的比较