啃碎并发（八）：深刻分析wait¬ify原理

时间 2019-11-29

标签并发深刻分析 wait¬ify wait notify 原理栏目 Java 繁體版

原文原文链接

0 前言

上一节讲了Synchronized关键词的原理与优化分析，而配合Synchronized使用的另外两个关键词wait&notify是本章讲解的重点。最简单的东西，每每包含了最复杂的实现，由于须要为上层的存在提供一个稳定的基础，Object做为Java中全部对象的基类，其存在的价值不言而喻，其中wait&notify方法的实现多线程协做提供了保证。java

1 源码

今天咱们要学习或者说分析的是 Object 类中的 wait&notify 这两个方法，其实说是两个方法，这两个方法包括他们的重载方法一共有 5 个，而 Object 类中一共才 12 个方法，可见这 2 个方法的重要性。咱们先看看 JDK 中的代码：bash

public final native void notify();

public final native void notifyAll();

public final void wait() throws InterruptedException {
    wait(0);
}

public final native void wait(long timeout) throws InterruptedException;

public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) {
        throw new IllegalArgumentException("timeout value is negative");
    }

    if (nanos < 0 || nanos > 999999) {
        throw new IllegalArgumentException(
                            "nanosecond timeout value out of range");
    }
    // 此处对于纳秒的处理不精准，只是简单增长了1毫秒，
    if (nanos > 0) {
        timeout++;
    }

    wait(timeout);
}
复制代码

就是这五个方法。其中有 3 个方法是 native 的，也就是由虚拟机本地的 c 代码执行的。有 2 个 wait 重载方法最终仍是调用了 wait（long）方法。多线程

wait方法：wait是要释放对象锁，进入等待池。既然是释放对象锁，那么确定是先要得到锁。因此wait必需要写在synchronized代码块中，不然会报异常。ide
notify方法：也须要写在synchronized代码块中，调用对象的这两个方法也须要先得到该对象的锁。notify，notifyAll，唤醒等待该对象同步锁的线程。notify唤醒对象等待池中的一个线程，将这个线程放入该对象的锁池中。对象的锁池中线程能够去竞争获得对象锁，而后开始执行。学习
1. 若是是经过notify来唤起的线程，那先进入wait的线程会先被唤起来，并不是随机唤醒；
2. 若是是经过nootifyAll唤起的线程，默认状况是最后进入的会先被唤起来，即LIFO的策略；
另外一点，notify，notifyAll调用时并不会释放对象锁。好比如下代码：优化
```
public void test() {
    Object object = new Object();
    synchronized (object){
        object.notifyAll();
        while (true){
         
        }
    }
}
复制代码
```
虽然调用了notifyAll，可是紧接着进入了一个死循环。致使一直不能出临界区，一直不能释放对象锁。因此，即便它把全部在等待池中的线程都唤醒放到了对象的锁池中，可是锁池中的全部线程都不会运行，由于他们都拿不到锁。ui

2 用法

简单示例：spa

public class WaitNotifyCase {
    public static void main(String[] args) {
        final Object lock = new Object();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread A is waiting to get lock");
                synchronized (lock) {
                    try {
                        System.out.println("thread A get lock");
                        TimeUnit.SECONDS.sleep(1);
                        System.out.println("thread A do wait method");
                        lock.wait();
                        System.out.println("wait end");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("thread B is waiting to get lock");
                synchronized (lock) {
                    System.out.println("thread B get lock");
                    try {
                        TimeUnit.SECONDS.sleep(5);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    lock.notify();
                    System.out.println("thread B do notify method");
                }
            }
        }).start();
    }
}
复制代码

执行结果：线程

thread A is waiting to get lock
thread A get lock
thread B is waiting to get lock
thread A do wait method
thread B get lock
thread B do notify method
wait end
复制代码

前提：必须由同一个lock对象调用wait、notify方法code

当线程A执行wait方法时，该线程会被挂起；

当线程B执行notify方法时，会唤醒一个被挂起的线程A；

lock对象、线程A和线程B三者是一种什么关系？根据上面的结论，能够想象一个场景：

lock对象维护了一个等待队列list；

线程A中执行lock的wait方法，把线程A保存到list中；

线程B中执行lock的notify方法，从等待队列中取出线程A继续执行；