多线程编程核心技术(六)用"等待-通知"机制优化循环等待

死锁的一种解决方式可以通过循环来对资源进行重复请求做到。循环的作用就是为了获取资源。

// 一次性申请转出账户和转入账户，直到成功
while(!actr.apply(this, target))
  ；

如果 apply() 操作耗时非常短，而且并发冲突量也不大时，这个方案还挺不错的，因为这种场景下，循环上几次或者几十次就能一次性获取转出账户和转入账户了。但是如果 apply() 操作耗时长，或者并发冲突量大的时候，循环等待这种方案就不适用了，因为在这种场景下，可能要循环上万次才能获取到锁，太消耗 CPU 了。

为了获取资源，也就是前置条件，如果资源就绪了就主动发送给需要资源的对象就好了。Java语言是支持等待-通知机制的。

完整的等待 - 通知机制：线程首先获取互斥锁，当线程要求的条件不满足时，释放互斥锁，进入等待状态；当要求的条件满足时，通知等待的线程，重新获取互斥锁。

在synchronized实现的互斥锁，可以通过wait(),notify(),notifyAll()来实现。

当线程执行wait()方法时候，会释放当前的锁，然后让出CPU，进入等待状态。

所有最简单的就是先让一个线程进来，然后询问他是否完成了所有的前置条件(校验)，如果没有就wait()，以释放自己的资源。

在释放了资源之后就会进入线程的等待队列，这个队列也是互斥锁的等待队列。wait后的线程会进入一个FIFO队列中，notify是一个有序的出队列的过程。

 

 而notify和notifyAll则是用来通知等待队列的

在并发程序中，当一个线程进入临界区后，由于某些条件不满足，需要进入等待状态，Java 对象的 wait() 方法就能够满足这种需求。如上图所示，当调用 wait() 方法后，当前线程就会被阻塞，并且进入到右边的等待队列中，这个等待队列也是互斥锁的等待队列。 线程在进入等待队列的同时，会释放持有的互斥锁，线程释放锁后，其他线程就有机会获得锁，并进入临界区了。

 

因为 notify() 只能保证在通知时间点，条件是满足的。而被通知线程的执行时间点和通知的时间点基本上不会重合，所以当线程执行的时候，很可能条件已经不满足了（保不齐有其他线程插队）。而且 wait()、notify()、notifyAll() 这三个方法能够被调用的前提是已经获取了相应的互斥锁，所以我们会发现 wait()、notify()、notifyAll() 都是在 synchronized{}内部被调用的。如果在 synchronized{}外部调用，或者锁定的 this，而用 target.wait() 调用的话，JVM 会抛出一个运行时异常：java.lang.IllegalMonitorStateException。

 等待 - 通知机制是一种非常普遍的线程间协作的方式。工作中经常看到有同学使用轮询的方式来等待某个状态，其实很多情况下都可以用今天我们介绍的等待 - 通知机制来优化。Java 语言内置的 synchronized 配合 wait()、notify()、notifyAll() 这三个方法可以快速实现这种机制，但是它们的使用看上去还是有点复杂，所以你需要认真理解等待队列和 wait()、notify()、notifyAll() 的关系。

练习代码：使用wait和notify完成累加功能

wait会让出CPU而notify不会，notify重在于通知使用object的对象“我用完了！”，wait重在通知其它同用一个object的线程“我暂时不用了”并且让出CPU。

public class NotifyThread extends Thread {
    private final Object lock;

    private Integer num =0;

    public NotifyThread(Object lock,Integer num) {
        super();
        this.lock = lock;
        this.num = num;
    }

    @Override
    public void run() {
        synchronized (lock) {
            // 做一些业务逻辑相关的事。。。。
            while (num<11){
                num++;
                try {
                    Thread.sleep(300);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                // 业务逻辑完成了...
                System.out.println("开始 notify time= " + System.currentTimeMillis());
                lock.notify();
                System.out.println("结束 notify time= " + System.currentTimeMillis());
                System.out.println("num: "+num);
            }
        }
    }
}

　　

public class WaitThread extends Thread {
    private final Object lock;

    private Integer num =0;
    public WaitThread(Object lock,Integer num) {
        super();
        this.lock = lock;
        this.num = num;
    }

    @Override
    public void run() {
        try {
            synchronized (lock) {
                long start = System.currentTimeMillis();
                System.out.println("开始 wait time= " + start);
                lock.wait();
                long end = System.currentTimeMillis();
                System.out.println("结束 wait time= " + end);
                System.out.print("wait time = " + (end - start));
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}