前言：

等待/通知机制主要由Object类中的wait()、notify() 和 notifyAll()三个方法来实现，这三个方法均非Thread类中所声明的方法，而是Object类中声明的方法；原因是每个对象都拥有monitor（锁），所以让当前线程等待某个对象的锁，当然应该通过这个对象来操作，而不是用当前线程来操作

wait()——让当前线程释放对象锁并进入等待（阻塞）状态，在调用wait方法之前，线程必须获得该对象的对象级别锁，即只能在同步方法或同步块中调用wait方法。

notify()——唤醒一个正在等待相应对象锁的线程，使其进入就绪队列，以便在当前线程释放锁后竞争锁，进而得到CPU的执行，和wait方法一样，线程也必须获得该对象的对象级别锁，也只能在同步方法或同步块中调用。

notifyAll()——唤醒所有正在等待相应对象锁的所有线程，其它和notify一样。

一、举例说明

这里举一个生产面包和销售面包的例子，代码如下

声明一个面包类

public class Bread {

 public String name;
 public int num;
 Bread(String name, int num) {
     System.out.println("面包名称：" + name + ", 初始化数量：" + num);
     this.name = name;
     this.num = num;
 }

}

声明一个生产面包的类，produce() 方法每次调用会生产一个面包，其调用受run()方法控制。

public class BreadProducer implements Runnable {

 private final Bread bread;
 private int maxNum;
 BreadProducer(Bread bread, int maxNum) {
     this.bread = bread;
     this.maxNum = maxNum;
 }
 public void produce() {
     bread.num = bread.num + 1;
     System.out.println("面包生产1个,当前数量：" + bread.num);
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }
 public void run() {
     synchronized (bread) {
         if (bread.num >= maxNum) {
             System.out.println("面包生产数量达到巅峰，停止生产，等待卖出");
             try {
                 System.out.println("***************");
                 bread.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         } else {
             System.out.println("---------------");
             produce();
             bread.notifyAll();  // 调用生产方法以后会唤醒wait等待的线程
         }
     }
 }

}

声明一个售卖面包的类，sale() 方法每次调用会销售一个面包，其调用受run()控制

public class BreadSale implements Runnable {

 private final Bread bread;
 BreadSale(Bread bread) {
     this.bread = bread;
 }
 private void sale() {
     bread.num = bread.num - 1;
     System.out.println("面包售卖一个，当前剩余：" + bread.num);
     try {
         Thread.sleep(1000);
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
 }
 public void run() {
     synchronized (bread) {
         if (bread.num <= 0) {
             System.out.println("面包已卖完，等待生产");
             try {
                 bread.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         } else {
             sale();
             bread.notifyAll();   // 调用销售方法以后会唤醒wait等待的线程
         }
     }
 }

}

写一个测试方法

package thread.wait;

public class Main {

 public static void main(String[] args) throws InterruptedException {
     Bread bread = new Bread("土司", 1);
     BreadProducer breadProducer = new BreadProducer(bread, 2);
     BreadSale breadSale = new BreadSale(bread);
     Thread tp = new Thread(breadProducer);
     Thread ts = new Thread(breadSale);
     ts.start();
     tp.start();
 }

}

结果（两个线程启动顺序不同结果不同）：

面包名称：土司, 初始化数量：1
面包售卖一个，当前剩余：0
---------------
面包生产1个,当前数量：1

根据上面的输出，可以判断：

1). 线程ts先启动执行，调用 BreadSale 中的run()方法，run()方法调用 sale() 方法，而后唤醒所有等待bread锁的进程（看结果唤醒的是 tp 进程），而后该线程逐步结束

2). 线程tp启动后调用 BreadProducer 中的run()方法，run()方法调用 produce() 方法，而后唤醒所有等待bread锁的进程（这时候tp已经结束，没有线程等待，所以直接结束了）

二、举例延申

考虑到上述是生产面包售卖面包是一个持续的变化过程（即通常描述的生产-消费模式），可以对两个多线程类稍加改造，加入while(true) 的循环，这样就能一直持续这种生产-销售过程。

public class BreadProducer implements Runnable {
    private final Bread bread;
    private int maxNum;
    BreadProducer(Bread bread, int maxNum) {
        this.bread = bread;
        this.maxNum = maxNum;
    }
    public void produce() {
        bread.num = bread.num + 1;
        System.out.println("面包生产1个,当前数量：" + bread.num);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void run() {
        synchronized (bread) {
            while (true) {
                if (bread.num >= maxNum) {
                    System.out.println("面包生产数量达到巅峰，停止生产，等待卖出");
                    try {
                        System.out.println("***************");
                        bread.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println("---------------");
                    produce();
                    bread.notifyAll();
                }
            }
        }
    }
}
public class BreadSale implements Runnable {
    private final Bread bread;
    BreadSale(Bread bread) {
        this.bread = bread;
    }
    private void sale() {
        bread.num = bread.num - 1;
        System.out.println("面包售卖一个，当前剩余：" + bread.num);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public void run() {
        synchronized (bread) {
            while (true) {
                if (bread.num <= 0) {
                    System.out.println("面包已卖完，等待生产");
                    try {
                        bread.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    sale();
                    bread.notifyAll();
                }
            }
        }
    }
}
public class Main {
    public static void main(String[] args) throws InterruptedException {
        Bread bread = new Bread("土司", 3);
        BreadProducer breadProducer = new BreadProducer(bread, 5);
        BreadSale breadSale = new BreadSale(bread);
        Thread tp = new Thread(breadProducer);
        Thread ts = new Thread(breadSale);
        ts.start();
        tp.start();
    }
}