等待与唤醒机制之间的通信：

等待与唤醒机制之间的通信：

重点：有效的利用资源资源(（生产者）包子先生与（消费者）吃货包子案例)

通信：对包子的状态进行判断：

—没有包子–吃货先生唤醒包子先生–吃货先生等待包子(wait --wait set–在等待机制中，不会占用CPU资源)–包子先生做包子–包子先生做好包子—包子先生修改包子状态为有包子

—有包子—包子先生唤醒吃货先生吃包子（notify–）----包子先生停止做包子—吃货包子吃包子–吃货吃完包子–修改包子的状态为没有包子

…

wait/notify：他们在同一个机制中，不能同时用（抽象里面的必须重写）

资源类需要哪些类？

包子与包子铺案例

包子类：（属性：皮，陷）

包子状态：有true，没有false：

生产者（包子铺类）是一个线程类，可以继承Threa，

设置线程任务：生产包子，对包子状态进行判断，

ture：有包子包子铺进入wait方法进入等待状态

false：没有包子

包子铺生产包子；

增加一些趣味：交替生产两种包子

两种状态(i%20(i模2等等于0),i%21（i模2等等1）)

包子铺生产好包子

修改状态为true有

修改好之后唤醒吃货线程吃包子

消费者也是一个线程，也可以继承Thread

设置线程任务（run）：吃包子

对包子状态进行判断

false:没有包子

等待调用wait进入等待状态

true：有包子，吃包子，吃完包子修改包子状态为false没有

唤醒包子铺先生生产包子

测试类：包含main方法的类，启动程序

创建包子对象

开启包子铺线程（生产），开启吃货线程（吃）

代码实现：

//包子铺类
public class productBZ extends Thread {
    private baozi bz;

    public productBZ(String name, baozi bz) {
        super(name);
        this.bz = bz;
    }

    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (bz) {
                if (bz.State ==true) {
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                }
                //没有包子
                //被唤醒了之后，包子铺开始生产包子
                System.out.println("包子铺做包子");
                if (count % 2 == 0) {
                    bz.setBaozipi("薄皮");
                    bz.setBaozixian("三鲜肉");
                    System.out.println(getName() + bz.getBaozipi() + bz.getBaozixian() + "包子");
                } else {

                    bz.setBaozipi("冰皮");
                    bz.setBaozixian("牛肉馅");
                    System.out.println("包子铺生产了" + bz.getBaozipi() + bz.getBaozixian() + "包子");
                }
                count++;
                System.out.println("包子铺做好了包子，修改包子状态为有");
                bz.State=true;
                System.out.println("包子铺唤醒吃货,吃货可以开吃啦！");
                bz.notify();


            }
        }
    }
}

//吃货类
public class eatBZ extends Thread{
    private  baozi bz;

    public eatBZ(String name, baozi bz) {
        super(name);
        this.bz = bz;
    }

    @Override
    public void run() {
        while (true){

                synchronized (bz){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (bz.State==true) {
                        System.out.println("吃包子");
                        System.out.println("吃完包子");
                        bz.State=false;
                        System.out.println("吃货唤醒包子铺生产包子");
                        bz.notify();
                        System.out.println("----------------");
                    }
                    else {
                        //没有包子处于等待状态
                        try {
                            bz.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

}

//包子类
public class baozi {
    private String baozixian;
    private String baozipi;
    int count = 0;
    //初始状态为：没包子
    boolean State = false;

    public boolean isState() {
        return State;
    }

    public void setState(boolean state) {
        State = state;
    }

    public baozi(String baozixian, String baozipi, boolean state) {
        this.baozixian = baozixian;
        this.baozipi = baozipi;
        State = state;
    }


    public baozi() {
    }

    public String getBaozixian() {
        return baozixian;
    }

    public void setBaozixian(String baozixian) {
        this.baozixian = baozixian;
    }

    public String getBaozipi() {
        return baozipi;
    }

    public void setBaozipi(String baozipi) {
        this.baozipi = baozipi;
    }
}

//测试类
public class demoBaozi {
    public static void main(String[] args) {
        baozi bz=new baozi();
        productBZ p=new productBZ("包子铺",bz);
        p.start();

        eatBZ e=new eatBZ("吃货",bz);
        e.start();

    }
}