你知道wait(), notify/notifyall 的用法吗，如果不知道你就太low,请听下文详解

前言

大家在多线程开发过程中，经常会用到wait 线程等待，线程唤醒notify()。

一个线程A 调用了对象O 的wait()方法进入等待状态，而另一个线程B
调用了对象O 的notify()或者notifyAll()方法，线程A 收到通知后从对象O 的wait()
方法返回，进而执行后续操作。上述两个线程通过对象O 来完成交互，而对象
上的wait()和notify/notifyAll()的关系就如同开关信号一样，用来完成等待方和通
知方之间的交互工作。

notify()：
通知一个在对象上等待的线程,使其从wait 方法返回,而返回的前提是该线程
获取到了对象的锁，没有获得锁的线程重新进入WAITING 状态。

notifyAll()：
通知所有等待在该对象上的线程

wait()
调用该方法的线程进入WAITING 状态,只有等待另外线程的通知或被中断
才会返回.需要注意,调用wait()方法后,会释放对象的锁

wait(long)
超时等待一段时间,这里的参数时间是毫秒,也就是等待长达n 毫秒,如果没有
通知就超时返回

wait (longint)
对于超时时间更细粒度的控制,可以达到纳秒

等待和通知的标准范式

在wait(), notify/notifyall 一定要锁对象，而且包含在synchronized方法或代码块中

等待方遵循如下原则。
1）获取对象的锁。
2）如果条件不满足，那么调用对象的wait()方法，被通知后仍要检查条件。
3）条件满足则执行对应的逻辑。

synchronized(对象){

   while(条件不满足){
      对象.wait(); //等待，会释放锁
   }
   //todosomething 对应的处理逻辑
}

通知方遵循如下原则。
1）获得对象的锁。
2）改变条件。
3）通知所有等待在对象上的线程。

synchronized(对象){

      改变条件;
      对象.notifyall(); //唤醒，不会释放锁
   }
   //todosomething 执行完所有业务代码才释放锁
}

比如wait

synchronized（对象）{
wait();//等待，会释放锁
}
todosomething

比如notify/notifyall

synchronized（对象）{
notify/notifyall(); //唤醒，不会释放锁
}
todosomething;//执行完所有业务代码才释放锁

举例

列举一个快递的例子

package cn.enjoyedu.ch1.wn;

/**
 *类说明：快递实体类
 */
public class Express {
    public final static String CITY = "ShangHai";
    private int km;/*快递运输里程数*/
    private String site;/*快递到达地点*/

    public Express() {
    }

    public Express(int km, String site) {
        this.km = km;
        this.site = site;
    }

    /* 变化公里数，然后通知处于wait状态并需要处理公里数的线程进行业务处理*/
    public synchronized void changeKm(){
        this.km = 101;
        notify();
    }

    /* 变化地点，然后通知处于wait状态并需要处理地点的线程进行业务处理*/
    public  synchronized  void changeSite(){
        this.site = "BeiJing";
        notifyAll();
    }

    /*线程等待公里的变化*/
    public synchronized void waitKm(){
        while(this.km<100){
            try {
                wait();
                System.out.println("Check Site thread["
                                +Thread.currentThread().getId()
                        +"] is be notified");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("the Km is "+this.km+",I will change db");
    }

    /*线程等待目的地的变化*/
    public synchronized void waitSite(){
        while(this.site.equals(CITY)){//快递到达目的地
            try {
                wait();
                System.out.println("Check Site thread["+Thread.currentThread().getId()
                		+"] is be notified");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println("the site is "+this.site+",I will call user");
    }
}

测试类

测试类如下

package cn.enjoyedu.ch1.wn;

/**
 *类说明：测试wait/notify/notifyAll
 */
public class TestWN {
    private static Express express = new Express(0,Express.CITY);

    /*检查里程数变化的线程,不满足条件，线程一直等待*/
    private static class CheckKm extends Thread{
        @Override
        public void run() {
        	express.waitKm();
        }
    }

    /*检查地点变化的线程,不满足条件，线程一直等待*/
    private static class CheckSite extends Thread{
        @Override
        public void run() {
        	express.waitSite();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        for(int i=0;i<3;i++){
            new CheckSite().start();
        }
        for(int i=0;i<3;i++){
            new CheckKm().start();
        }

        Thread.sleep(1000);
        express.changeKm();//快递地点变化
    }
}

写在最后

在调用wait（）、notify()系列方法之前，线程必须要获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait（）方法、notify()系列方法，进入wait（）方法后，当前线程释放锁，在从wait（）返回前，线程与其他线程竞争重新获得锁，执行notify()系列方法的线程退出调用了notifyAll 的synchronized代码块的时候后，他们就会去竞争。如果其中一个线程获得了该对象锁，它就会继续往下执行，在它退出synchronized 代码块，释放锁后，其他的已经被唤醒的线程将会继续竞争获取该锁，一直进行下去，直到所有被唤醒的线程都执行完毕。

notify 和notifyAll 应该用谁尽可能用notifyall()，谨慎使用notify()，因为notify()只会唤醒一个线程，我们无法确保被唤醒的这个线程一定就是我们需要唤醒的线程

如果你觉得不错，请给一个star并关注我吧 ^_