Java多线程--wait(),notify(),notifyAll()的用法

忙等待没有对运行等待线程的 CPU 进行有效的利用（而且忙等待消耗cpu过于恐怖，请慎用），除非平均等待时间非常短。否则，让等待线程进入睡眠或者非运行状态更为明智，直到它接收到它等待的信号。

Java 有一个内建的等待机制来允许线程在等待信号的时候变为非运行状态。java.lang.Object 类定义了三个方法，wait()、notify()和 notifyAll()来实现这个等待机制。

但在使用wait()、notify()和 notifyAll()必须获取该对象的锁，否则的话会抛异常IllegalMonitorStateException！

wait():沉睡当前线程。

notify()：随机唤醒一个正在等待当前对象的线程，不可以指定唤醒哪一个。

notify()：唤醒所有正在等待当前对象的线程。

注意（同步块）：

1.当一个线程被唤醒以后，并不会立即退出wait()方法去执行接下来的代码，直到调用notify()方法的线程退出它自己的同步块以后。

2.同样的使用notifyAll()方法以后，并不是所有的线程都会立即退出wait()方法，获得该对象锁的线程一个接一个的退出。

import org.junit.Test;

import static java.lang.Thread.sleep;

public class MyWaitNotify {

    public class Monitor{

    }

    Monitor monitorObject = new Monitor();
    boolean waitSign = false;

    public void doWait(){
        synchronized (monitorObject){
            while (!waitSign)
            {
                try {
                    monitorObject.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public void doNotify(){
        synchronized (monitorObject){
            waitSign=true;
            monitorObject.notify();
        }
    }

    public void doNotifyAll(){
        synchronized (monitorObject){
            waitSign=true;
            monitorObject.notifyAll();
        }
    }

    @Test
    public void testNotify(){

        new Thread(){
            public void run(){
                try {
                    System.out.println("线程1:启动");
                    sleep(5000);
                    System.out.println("线程1:notify；");
                    doNotify();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("子线程结束");
            }
        }.start();

        System.out.println("主线程wait");
        doWait();
        System.out.println("主线程被激活");
    }

    @Test
    public void testNotifyAll() {

        new Thread(){
            public void run(){
                try {
                    System.out.println("线程1:启动");
                    sleep(5000);
                    System.out.println("线程1:notifyAll；");
                    doNotifyAll();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1：结束");
            }
        }.start();

        new Thread(){
            public void run(){
                System.out.println("线程2：等待");
                doWait();
                try {
                    sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2：激活");
                System.out.println("线程2：结束");
            }
        }.start();

        System.out.println("主线程wait");
        doWait();
        System.out.println("主线程：激活");
        try {
            sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("主线程：完成");
    }

}

MyWaitNotify类中：

1.testNotify()方法中，测试了主线程wait，子线程notify。

2.testNotifyAll()方法中，测试了主线程wait，子线程2wait，子线程1notifyAll。

注意容易发生的问题：

1.notify()方法执行在wait()方法之前，那么会造成调用wait()方法的线程永远在等待，不在醒来。

解决方法：将notify()信号通过变量存储，任何一个线程需要wait()之前必须要检测该变量，保证没有notify才能wait。

2.调用wait()等待的线程可能会出现“假唤醒”的情况，也就是在没有notify()的情况下，调用wait()的线程自动醒来。

解决方法：通过while循环检测notify()信号变量，如果notify()信号变量表示没有线程执行过notify()那说明确实是“假唤醒”，则需要继续wait()。

public void doWait(){
        synchronized (monitorObject){
            while (!waitSign)
            {
                try {
                    monitorObject.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

参考文档：http://wiki.jikexueyuan.com/project/java-concurrent/thread-communication.html