讲讲java同步机制的wait和notify

1、wait和notify的使用与区别

对于wait()和notify()的理解，还是要从jdk官方文档中开始，在Object类方法中有：

void notify() 

Wakes up a single thread that is waiting on this object’s monitor.
译：唤醒在此对象监视器上等待的单个线程

void notifyAll() 

Wakes up all threads that are waiting on this object’s monitor.
译：唤醒在此对象监视器上等待的所有线程

void wait( ) 

Causes the current thread to wait until another thread invokes the notify() method or the notifyAll( ) method for this object.
译：导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法

void wait(long timeout) 

Causes the current thread to wait until either another thread invokes the notify( ) method or the notifyAll( ) method for this object, or a specified amount of time has elapsed.
译：导致当前的线程等待，直到其他线程调用此对象的notify() 方法或 notifyAll() 方法，或者指定的时间过完。

void wait(long timeout, int nanos) 

Causes the current thread to wait until another thread invokes the notify( ) method or the notifyAll( ) method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
译：导致当前的线程等待，直到其他线程调用此对象的notify( ) 方法或 notifyAll( ) 方法，或者其他线程打断了当前线程，或者指定的时间过完。

上面是官方文档的简介，下面我们根据官方文档总结一下：

• wait( )，notify( )，notifyAll( )都不属于Thread类，而是属于Object基础类，也就是每个对象都有wait( )，notify( )，notifyAll( ) 的功能，因为每个对象都有锁，锁是每个对象的基础，当然操作锁的方法也是最基础了。
• 当需要调用以上的方法的时候，一定要对竞争资源进行加锁，如果不加锁的话，则会报 IllegalMonitorStateException 异常。
• 当想要调用wait( )进行线程等待时，必须要取得这个锁对象的控制权（对象监视器），一般是放到synchronized(obj)代码中。
• 在while循环里而不是if语句下使用wait，这样，会在线程暂停恢复后都检查wait的条件，并在条件实际上并未改变的情况下处理唤醒通知。
• 调用obj.wait( )释放了obj的锁，否则其他线程也无法获得obj的锁，也就无法在synchronized(obj){ obj.notify() } 代码段内唤醒A。
• notify( )方法只会通知等待队列中的第一个相关线程（不会通知优先级比较高的线程）。
• notifyAll( )通知所有等待该竞争资源的线程（也不会按照线程的优先级来执行）。
• 假设有三个线程执行了obj.wait( )，那么obj.notifyAll( )则能全部唤醒tread1，thread2，thread3，但是要继续执行obj.wait（）的下一条语句，必须获得obj锁，因此，tread1，thread2，thread3只有一个有机会获得锁继续执行，例如tread1，其余的需要等待thread1释放obj锁之后才能继续执行。
• 当调用obj.notify/notifyAll后，调用线程依旧持有obj锁，因此，thread1，thread2，thread3虽被唤醒，但是仍无法获得obj锁。直到调用线程退出synchronized块，释放obj锁后，thread1，thread2，thread3中的一个才有机会获得锁继续执行。

2、wait和notify简单使用示例

package com.concurrent;

/**
 * @author riemann
 * @date 2019/08/03 15:35
 */
public class WaitNotifyTest {

    // 在多线程间共享的对象上使用wait
    private String[] shareObj = {"true"};

    public static void main(String[] args) {
        WaitNotifyTest wnTest = new WaitNotifyTest();
        ThreadWait threadWait1 = wnTest.new ThreadWait("wait thread1");
        ThreadWait threadWait2 = wnTest.new ThreadWait("wait thread2");
        ThreadWait threadWait3 = wnTest.new ThreadWait("wait thread3");
        threadWait1.setPriority(1);
        threadWait2.setPriority(2);
        threadWait3.setPriority(3);

        ThreadNotify threadNotify = wnTest.new ThreadNotify("notify thread");
        threadNotify.start();
        threadWait1.start();
        threadWait2.start();
        threadWait3.start();
    }

    class ThreadWait extends Thread {

        public ThreadWait(String name) {
            super(name);
        }

        public void run() {
            synchronized (shareObj) {
                while ("true".equals(shareObj[0])) {
                    System.out.println(this.getName() + " 开始等待");
                    long startTime = System.currentTimeMillis();
                    try {
                        shareObj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    long endTime = System.currentTimeMillis();
                    System.out.println(this.getName() + " 等待时间为: " + (endTime - startTime));
                }
            }
            System.out.println(getName() + " 等待结束");
        }

    }

    class ThreadNotify extends Thread {

        public ThreadNotify(String name) {
            super(name);
        }

        public void run() {
            try {
                // 给等待线程等待时间
                sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (shareObj) {
                System.out.println(this.getName() + " 开始准备通知");
                shareObj[0] = "false";
                shareObj.notifyAll();
                System.out.println(this.getName() + " 通知结束");
            }
            System.out.println(this.getName() + " 运行结束");
        }
    }

}

输出结果：

wait thread1 开始等待
wait thread3 开始等待
wait thread2 开始等待
notify thread 开始准备通知
notify thread 通知结束
notify thread 运行结束
wait thread2 等待时间为: 2998
wait thread2 等待结束
wait thread3 等待时间为: 3000
wait thread3 等待结束
wait thread1 等待时间为: 3000
wait thread1 等待结束

3、wait() 与 notify/notifyAll() 区别

当执行wait()时，线程会把持有的锁立即释放，线程处于block状态，调用对应的notify或者notifyAll方法，线程处于runnable状态，竞争到锁和cpu时间就重新执行

wait(100) 线程会把持有的锁立即释放，线程处于block状态，与wait()不同的是，当超过这个设置时间后，线程处于runnable状态，重新竞争锁和cpu时间来执行，当然也可以在线程block时，调用notify使其恢复到runnbale状态

当执行notify/notifyAll方法时，会唤醒处于block状态的线程，直到执行完同步块后再释放锁，所以notify或者notifyAll一般写在末尾

notify 是唤醒一个block线程，使其处于runnable状态，竞争获取到锁和CPU时间后继续执行

notifyAll是唤醒所有的block线程，使他们处于runnable状态，这些线程竞争获取锁和CPU时间后再继续执行