四、等待唤醒机制

目录

1.等待唤醒机制的提出

2.等待唤醒机制实现线程同步

3.Java 中的线程状态图

---

1.等待唤醒机制的提出

前一篇文章主要讲了线程之间互相竞争资源所引发的线程安全问题，但线程之间除了竞争关系以外还有协同合作的关系。

假设现在有老板和顾客两个人，老板负责做包子，顾客负责吃包子。顾客必须要等到包子做好才能吃，而老板为避免剩包子必须等吃完吃完包子再做。在这种情况下，两个线程必须通过等待唤醒机制，来控制彼此的行为。下面通过两者的行为图来进行分析：

① 老板刚开始并没有被顾客唤醒，因此一直处于等待状态，卡在第 1 步无法朝下执行；

② 与此同时顾客执行第 1 步，唤醒了老板，然后继续朝下执行到第 2 步，此时老板还没有执行到第 3 步，无法唤醒顾客，顾客进入等待状态；

③ 老板被顾客唤醒开始做包子，在做好包子之后唤醒了顾客；

④ 顾客被老板唤醒之后开始吃包子。

2.等待唤醒机制实现线程同步

等待唤醒机制我们已经理清楚了，那么在 Java 中如何通过等待唤醒机制来实现同步呢？Java 中的 Object 类为此机制提供了两个方法：wait ( ) 与 notify ( ) ，其中 wait ( ) 方法可以使线程在调用了此对象的 notify ( ) 方法执行之前无法向下执行，而 notify ( ) 方法则可以使被此对象的 wait ( ) 方法阻塞的线程继续向下执行。需要特别注意的是：这两个方法必须要用同步代码块包裹，而且调用它们的对象为同步代码块的锁对象。

从上面的分析中可以看出：老板等待顾客与顾客唤醒老板为一组上锁解锁的动作，老板唤醒顾客与顾客等待老板为一组上锁解锁的动作，因此需要两把锁来控制老板和顾客的同步。下面就来通过代码来实现刚才的案例：

    public static void main(String[] args) {

        Object lock1 = new Object();//顾客阻塞自己的锁对象
        Object lock2 = new Object();//老板阻塞自己的锁对象

        //做包子的线程
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    //老板等待顾客提出吃包子的请求
                    synchronized (lock2) {
                        try {
                            lock2.wait();
                        } catch (InterruptedException e) {
                        }
                    }
                    //老板开始做包子,需要3秒
                    System.out.println(" 老板开始做包子");
                    try {
                        System.out.println(" 三秒。。。。。");
                        sleep(3000);
                    } catch (InterruptedException e) {
                    }
                    System.out.println(" 老板包子做好了");
                    //通知顾客吃包子
                    synchronized (lock1) {
                        System.out.println("老板：客官你要的包子来了!");
                        lock1.notify();
                    }
                }
            }
        }.start();

        //吃包子的线程
        new Thread() {
            @Override
            public void run() {
                while (true) {
                    //顾客让老板做包子
                    synchronized (lock2) {
                        System.out.println("顾客：老板,来一笼包子!");
                        lock2.notify();
                    }
                    //顾客等待老板做包子
                    synchronized (lock1) {
                        try {
                            lock1.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //吃包子,需要2秒
                    System.out.println(" 顾客开始吃包子");
                    try {
                        System.out.println(" 两秒。。。。。");
                        sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(" 顾客包子吃完了");

                }
            }
        }.start();
    }

此时我们开启两个线程，查看老板和顾客的动作是否按照预期来执行？显然所有的动作都是按预期的顺序来执行的，这就说明此代码的逻辑是正确的，这也就实现了一个同步案例。

顾客：老板,来一笼包子!
 老板开始做包子
 三秒。。。。。
 老板包子做好了
老板：客官你要的包子来了!
 顾客开始吃包子
 两秒。。。。。
 顾客包子吃完了
顾客：老板,来一笼包子!
 老板开始做包子
 三秒。。。。。
 老板包子做好了
老板：客官你要的包子来了!
 顾客开始吃包子
 两秒。。。。。
 顾客包子吃完了

注意：

① wait ( ) 方法除了无参方法以外，还可以传入毫秒值，即等待毫秒值时间之后线程仍没有被唤醒则强制唤醒该线程。

② notify ( ) 方法每次只会唤醒该锁（对象监视器）中等待的一个线程，若要唤醒所有在该锁上等待的线程，则要用notifyAll ( ) 方法。

③ 在使用上面两个方法时必须要用同步代码块包裹起来，因为只有通过同步代码块才能生成锁对象来调用这两个方法。

3.Java 中的线程状态图