生产者消费者模拟Java多线程wait()、notifyAll()使用场景

简介

本文通过一个标准的使用实例，来讲解Java中wait()、notifyAll()这两个方法的作用和使用的重点。

一.wait()、notify()系列方法

wait()：线程在同步代码中使用该方法，会让当前线程进入等待状态，并让线程释放对共享对象的锁，代码会在方法返回前（即被notify()等方法唤醒）一直等待cpu给予资源。

wait(long timeout)：参数是一个自定义的超时时间，过了这个时间如果线程没有被notify()唤醒，则函数还是会返回。如果传递一个负数timeout会抛出IllegalArgumentException异常。

notify()：会让调用了wait()系列方法的“一个”线程释放锁，并通知其它正在等待（调用了wait()方法）的线程竞争锁。

notifyAll()：唤醒所有在共享变量上由于调用wait系列方法而被挂起的线程。

注意：

1. 调用wait()、notify()方法时，当前线程必须要成功获得锁（必须写在同步代码块锁中），否则将抛出异常。
2. 只对当前单个共享变量生效，多个共享变量需要多次调用wait()方法。
3. 如果线程A调用wait()方法后处于堵塞状态时，其他线程中断（在其他线程调用A.interrupt()方法）A线程，则会抛出InterruptExcption异常而返回并终止。

二、标准代码实例（简单的生产者消费者模型）

1、实例流程介绍

1. 创建两个线程类，一个Cooker厨师类，一个Customer顾客类；
2. 创建一个Desk桌子中间类，用于存放汉堡包、每日顾客最多可食用汉堡包个数以及Cooker厨师类与Customer顾客类公用的对象锁；
   2.1 顾客来到桌子前想吃汉堡，如果桌子上有汉堡(flag==true)，则顾客开始进食，并在进食完毕后唤醒notifyAll()厨师制作汉堡，今日顾客可食用汉堡数量减一(count--)；如果桌子没有汉堡(flag==false)，则开始等待wait()，直到厨师把汉堡制作完成放置在桌子上(flag==true)并唤醒notifyAll()顾客进食；
   2.2 厨师来到桌子前，如果桌子上有汉堡(flag==true)，则等待顾客吃掉桌子上的汉堡(count--)，直到顾客吃完汉堡并唤醒notifyAll()厨师制作汉堡；

2、代码实现

2-1 Cooker类

public class Cooker extends Thread {

    public Cooker(String name) {
        super(name);
    }

    private static void log(String desc){
        System.out.println(Thread.currentThread().getName() + " : " + desc);
    }

    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                log("--------------进入厨师共同代码段！"+"顾客今日可食用汉堡剩余数为【"+Desk.count+"】个！");
                if(Desk.count==0){//今日顾客吃的汉堡包剩余数为0，不再生产
                    log("不再生产！");
                    break;
                }else{
                    if(!Desk.flag){//桌子上没有汉堡包
                        Desk.flag = true;//汉堡包放在桌子上
                        Desk.lock.notifyAll();//唤醒
                        log("桌子上没有汉堡包，厨师把汉堡包制作好放在桌子上并唤醒顾客吃汉堡包！");
                    }else{//桌子上有汉堡包
                        try {
                            log("桌子上有汉堡包，厨师在等顾客吃掉汉堡包！");
                            Desk.lock.wait();//（释放锁）厨师在等顾客吃掉汉堡包
                            log("正在等待的厨师被唤醒，准备下一步操作！");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

2-2 Customer类

public class Customer extends Thread {
    public Customer(String name) {
        super(name);
    }

    private static void log(String desc){
        System.out.println(Thread.currentThread().getName() + " : " + desc);
    }

    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                log("--------------进入顾客共同代码段！"+"顾客今日可食用汉堡剩余数为【"+Desk.count+"】个！");
                if(Desk.count==0){//今日顾客吃的汉堡包剩余数为0
                    log("顾客被赶出餐厅！");
                    break;
                }else{
                    if(Desk.flag){//桌子上有汉堡包
                        Desk.flag = false;//桌子上的汉堡包已被吃掉
                        Desk.count--;//吃完汉堡包，顾客今日可食用汉堡剩余数减一
                        Desk.lock.notifyAll();//唤醒
                        log("桌子上有汉堡包，汉堡包被吃掉并唤醒厨师制作汉堡包！");
                    }else{//桌子上没有汉堡包
                        try {
                            log("桌子上没有汉堡包，顾客在等待厨师制作汉堡包！");
                            Desk.lock.wait();//（释放锁）顾客等待汉堡包被制作好
                            log("正在等待的顾客被唤醒，准备下一步操作！");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

2-3 Desk类

public class Desk {

    //true：桌子上有汉堡包    false：桌子上没有汉堡包
    public static boolean flag = false;

    //每天顾客最多能吃的汉堡包个数
    public static int count = 2;

    //厨师与顾客共同的锁
    public static Object lock = new Object();
}

2-4 Test类

public class Test {
    public static void main(String[] args) {
        Thread t1 = new Cooker("厨师");
        Thread t2 = new Customer("顾客");

        t1.start();
        t2.start();
    }
}

运行结果

厨师 : --------------进入厨师共同代码段！顾客今日可食用汉堡剩余数为【2】个！
厨师 : 桌子上没有汉堡包，厨师把汉堡包制作好放在桌子上并唤醒顾客吃汉堡包！
厨师 : --------------进入厨师共同代码段！顾客今日可食用汉堡剩余数为【2】个！
厨师 : 桌子上有汉堡包，厨师在等顾客吃掉汉堡包！
顾客 : --------------进入顾客共同代码段！顾客今日可食用汉堡剩余数为【2】个！
顾客 : 桌子上有汉堡包，汉堡包被吃掉并唤醒厨师制作汉堡包！
顾客 : --------------进入顾客共同代码段！顾客今日可食用汉堡剩余数为【1】个！
顾客 : 桌子上没有汉堡包，顾客在等待厨师制作汉堡包！
厨师 : 正在等待的厨师被唤醒，准备下一步操作！
厨师 : --------------进入厨师共同代码段！顾客今日可食用汉堡剩余数为【1】个！
厨师 : 桌子上没有汉堡包，厨师把汉堡包制作好放在桌子上并唤醒顾客吃汉堡包！
厨师 : --------------进入厨师共同代码段！顾客今日可食用汉堡剩余数为【1】个！
厨师 : 桌子上有汉堡包，厨师在等顾客吃掉汉堡包！
顾客 : 正在等待的顾客被唤醒，准备下一步操作！
顾客 : --------------进入顾客共同代码段！顾客今日可食用汉堡剩余数为【1】个！
顾客 : 桌子上有汉堡包，汉堡包被吃掉并唤醒厨师制作汉堡包！
顾客 : --------------进入顾客共同代码段！顾客今日可食用汉堡剩余数为【0】个！
顾客 : 顾客被赶出餐厅！
厨师 : 正在等待的厨师被唤醒，准备下一步操作！
厨师 : --------------进入厨师共同代码段！顾客今日可食用汉堡剩余数为【0】个！
厨师 : 不再生产！

结果分析

从执行的结果中，分析线程的执行顺序：

1. 如果是厨师线程t1先抢夺到对象锁的控制权，会先判断桌子上有没有汉堡包，如果没有就制作汉堡包并调用notifyAll()唤醒顾客线程，此时顾客线程会变为就绪状态；如果有就调用wait()等待，并释放掉对象锁暂停执行后续代码，即从wait()方法之后到run()方法结束的代码，都将立即暂停执行；
2. 当顾客线程t2抢夺到对象锁的控制权，会先判断桌子上有没有汉堡包，如果有就吃，并在之后调用notifyAll()唤醒厨师线程，此时厨师线程会变为就绪状态；如果没有就调用wait()等待，并释放掉对象锁暂停执行后续代码，即从wait()方法之后到run()方法结束的代码，都将立即暂停执行；
3. 在厨师开始wait()时，顾客notifyAll()厨师以后，此时不会立即释放对象锁，而是在执行完顾客那段synchronized 同步代码段，对象锁才会被释放，又因为同步代码段放在while(true)死循环里，所以此时会有新的一次顾客线程和已被唤醒的厨师线程进行竞争锁；反之同理；至于锁的控制权分配给哪个线程，完全看CPU心情。
4. 当之前处于wait()转变成就绪状态的线程此时获得对象锁的控制权，就会从之前等待的地方继续往下执行完synchronized 同步代码段，才会把对象锁的控制权交还给CPU；