【Java学习】等待唤醒机制

等待唤醒案例：线程之间的通信
创建一个顾客线程(消费者)：告知老板要的包子的种类和数量，调用wait方法，放弃cpu的执行，进入到WAITING状态(无限等待)
创建一个老板线程(生产者)：花了五秒做包子，做好包子之后，调用notify方法，唤醒顾客吃包子

注意：
顾客和老板线程必须使用同步代码块包裹起来，保证等待和唤醒只能有一个在执行
同步使用的锁对象必须保证唯一
只有锁对象才能调用wait和notify方法

Object类中的方法：
void wait() 在其他线程调用此对象的notify()方法或notifyAll() 方法前，导致当前线程等待
void notify() 唤醒在此对象监视器上等待的单个线程。会继续执行wait方法之后的代码

public class DemoWaitAndNotify {
    public static void main(String[] args) {
        Object obj = new Object();
        new Thread(){
            @Override
            public void run() {
                // 保证等待和唤醒的线程只能用一个执行，需要使用同步技术
                synchronized (obj) {
                    System.out.println("告诉老板包子的重类和数量");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("开始吃包子");
                }
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                try {
                    Thread .sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj) {
                    System.out.println("5秒做好包子，告知顾客");
                    obj.notify();
                }
            }
        }.start();
    }
}

进入到TimeWaiting(计时等待)有两种方式
1.使用sleep(long m)方法，在毫秒值结束后，线程睡醒进入到Runnable/Blocked状态
2.使用wait(long m)方法，wait方法如果在毫秒值结束忠厚，还没有被notify唤醒，就会自动醒来，线程睡醒进入到Runnable/Blocked状态

唤醒的方法:
void notify() 唤醒在此对象监视器上等待的单个线程
void notifyAll() 唤醒在此对象监视器上等待的所有线程
线程间通信：
概念:多个线程在处理同一一个资源,但是处理的动作(线程的任务)却不相同。

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

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

等待唤醒机制需求分析

public class Demo {
    public static void main(String[] args) {
        BaoZi bz = new BaoZi();
        new BaoZiPu(bz).start();
        new ChiHuo(bz).start();
    }
}
public class BaoZi {
    String pi;
    String xian;
    boolean flag = false;
}
public class BaoZiPu extends Thread{
    private BaoZi bz;

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

    @Override
    public void run() {
        int count= 0;
        while (true) {
            synchronized (bz) {
                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);
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                bz.flag = true;
                bz.notify();
                System.out.println("包子铺已经生产好了" + bz.pi + bz.xian);
            }
        }

    }
}
public class ChiHuo extends Thread{
    private BaoZi bz;

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

    @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);
                bz.flag = false;
                bz.notify();
                System.out.println("吃完了" + bz.pi + bz.xian);
            }
        }

    }
}