多线程12等待唤醒-包子铺案例

1. 等待唤醒机制

线程通信：多个线程在处理同一个资源，但是处理的动作（线程任务不同）却不相同。

比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为统一资源，线程A与线程B处理的动作，一个是生产一个是消费，那么线程A与线程B之间就存在线程通信

为什么要处理线程通信：

多个线程并发执行的，在默认情况下CPU是随机切换线程的，当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么线程之间需要一些协调通信，以此来帮助我们达到多线程共同操作一份数据。

如何保证线程间通信有效利用资源：

线程在处理一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量使用或操作，就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。也就是我们需要通过一定的手段使各个线程能有效率利用资源，而这种手段即—等待唤醒机制

什么是等待与唤醒机制：

这是多个线程间的一种协作机制，谈到线程我们经常想到的是线程间的竞争，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制，就好比在公司你和同事们，你们可能存在晋升时的竞争，但更多时候你们需要一起合作完成某些任务

就是在一个线程进行了规定的操作之后，就进入等待状态wait，等待其他线程执行完他们的指定代码后再将其唤醒notify，在有多个线程进行等待时，如果需要，可以使用notifyAll来唤醒所有等待的线程

等待唤醒中的方法：

1 wait() 线程不在活动，不在参与调度，进入wait set中，因此不会浪费cpu的资源，也不会去竞争锁了，这时的线程状态Waiting他还等待着别的线程执行notify  在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）

2 notify() 则选取所通知对象的wait set中的一个线程；例如，餐馆有位置后，等待就餐最久的顾客陷入做

3 notifyAll() 释放所通知对象wait set上的全部线程

当通知唤醒后的线程也不会立即恢复执行，因为当初中断的时候已经不在持有锁，如果能获取锁则线程从Waiting（无线等待）状态变成Runnable（运行）转态，否则，从wait set出来，线程从Waiting状态又变成Blockes（阻塞）状态

首先创建包子类aoZi：

package demo12等待唤醒包子铺案例;
/*
设置包子属性：
皮
馅
包子状态：有true，没有false
 */

public class BaoZi {
    //皮,馅，包子状态
    String pi;
    String xian;
    Boolean flag=false;
}

在创建包子铺类BaoZiPu：

package demo12等待唤醒包子铺案例;
/*
包子铺类：是一个线程类
设置线程任务run:生产包子
对包子转态进行判断：
true：有包子
   包子铺调用wait方法进入等待转态
false：没有包子
   包子铺生产包子
   增加一些趣味性：交替生产两种包子
      有两种状态：（i%2==0）
   包子铺生产好了包子，修改包子转态为true
   唤醒吃货线程进行吃包子

   注意：包子铺线程和吃货线程关系：通信（互斥）
   必须使用同步技术保证两个线程只能有一个在执行，锁对象必须保证唯一，可以使用包子对象作为一个锁对象，
   包子铺类和吃货类就需要把包子对象作为参数传递进来
      1.需要在成员位置创建一个包子变量
      2.使用带参数构造方法，为这个包子变量赋值
 */
public class BaoZiPu  extends Thread{
    //1.需要在成员变量位置创建一个包子变量,包子对象作为成员变量
    private BaoZi bz;
    //2.使用带参数构造方法，为这个包子变量赋值

    public BaoZiPu(BaoZi bz) {
        this.bz = bz;
    }

    //设置线程任务run：生产包子
    @Override
    public void run() {
        //定义一个变量
        int count=0;
        //使用while循环让包子铺一直生产包子
        while(true){
            //必须使用同步技术保证两个线程只能有一个在执行
            synchronized(bz){
                //d对包子状态进行判断
                if (bz.flag==true){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //唤醒之后：包子铺生产包子
                //增加趣味性：交替生产两种包子
                if (count%2==0){
                    //生产 薄皮三鲜馅包子
                    bz.pi="薄皮";
                    bz.xian="三鲜馅";
                }else{
                    bz.pi="冰皮";
                    bz.xian="牛肉大葱";
                }
                count++;
                System.out.println("包子铺正在生产："+bz.pi+bz.xian+"包子");
                //生产包子需要3秒种，让它睡3秒
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                // 包子铺生产好了包子，修改包子转态为true
                bz.flag=true;
                //唤醒吃货线程进行吃包子
                bz.notify();
                System.out.println("包子已经生产好了："+bz.pi+bz.xian+"包子，吃货可以开始吃了");
            }
        }

    }
}

再创建吃货类ChiHuo：

package demo12等待唤醒包子铺案例;
/*
消费者（吃货）：是一个线程类
设置线程任务run：吃包子
对包子状态进行判断：
   false：没有包子
      吃货调用wait方法进入等待状态
   true：有包子
      吃货吃包子，吃货吃完包子修改包子状态为false
      吃货唤醒包子铺线程，生产包子
 */

public class ChiHuo extends Thread {
    //1.需要在成员变量位置创建一个包子变量,包子对象作为成员变量
    private BaoZi bz;
    //2.使用带参数构造方法，为这个包子变量赋值

    public ChiHuo(BaoZi bz) {
        this.bz = bz;
    }
    //设置线程任务run：吃包子

    @Override
    public void run() {
        //使用死循环，让吃货一直吃包子
        while(true){
            //必须使用同步技术保证两个线程之鞥有一个在执行
            synchronized(bz){
                if(bz.flag==false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                //被唤醒之后执行的代码
                System.out.println("吃货正在吃："+bz.pi+bz.xian+"包子");
                //吃货吃完包子，修改包子转态false
                bz.flag=false;
                //吃货唤醒包子铺线程，生产包子
                bz.notify();
                System.out.println("吃货已经把："+bz.pi+bz.xian+"的包子吃完了，包子铺开始生产包子");
                System.out.println("----------------------------------------------------");
            }
        }
    }
}

最后创建测试类Text类：

package demo12等待唤醒包子铺案例;

public class Text {
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz=new BaoZi();
        //创建包子铺线程，开启生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启吃包子
        new ChiHuo(bz).start();
    }
}

结果：无限循环：