前言：

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

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

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

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

一、举例说明

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

1. 声明一个面包类

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;
    }
}

2. 声明一个生产面包的类，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等待的线程
            }

        }
    }

}

3. 声明一个售卖面包的类，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等待的线程
            }
        }
    }
}

4. 写一个测试方法

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();
    }
}

启动 main() 函数以后，可以看到一个持续生产-售卖的过程，永不停息（注意：慎用死循环）