进程间通信、等待唤醒机制

线程间通信

概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。
比如：线程A用来生成包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题。
多个线程在处理同一个资源，并且任务不同时，需要线程通信来帮助解决线程之间对同一个变量的使用或操作。 就是多个线程在操作同一份数据时，避免对同一共享变量的争夺。
也就是我们需要通过一定的手段使各个线程能有效的利用资源。而这种手段即 —— 等待唤醒机制。

等待唤醒机制

等待唤醒中的方法
等待唤醒机制就是用于解决线程间通信的问题的，使用到的3个方法的含义如下：
1. wait：线程不再活动，不再参与调度，进入 wait set 中，因此不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态即是 WAITING
它还要等着别的线程执行一个特别的动作，也即是“通知（notify）”在这个对象 上等待的线程从wait set 中释放出来，重新进入到调度队列（ready queue）中
2. notify：则选取所通知对象的 wait set 中的一个线程释放；例如，餐馆有空位置后，等候就餐最久的顾客最先 入座。
3. notifyAll：则释放所通知对象的 wait set 上的全部线程。

注意：
哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步块内，而此刻它已经不持有锁，所以她需要再次尝试去获取锁（很可能面临其它线程的竞争），成功后才能在当初调用 wait 方法之后的地方恢复执行。

总结如下：
如果能获取锁，线程就从 WAITING 状态变成 RUNNABLE 状态； 否则，从 wait set 出来，又进入 entry set，线程就从 WAITING 状态又变成 BLOCKED 状态

调用wait和notify方法需要注意的细节
1. wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对 象调用的wait方法后的线程。
2. wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继 承了Object类的。
3. wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

等待唤醒机制的实例

分析：
需要哪些类：
资源类（包子类）
    设置包子的属性：皮、馅、包子的状态：有（true）、没有（false）
生产者（包子铺）类：是一个线程类，可以继承Thread
    设置线程任务（run）：生产包子
    判断包子的状态：
        true：等待
        false:生产包子（交替生产两种包子（i%2==0））；生产好；修改包子状态为true；唤醒吃货线程
消费者（吃货）类：是一个线程类，可以继承Thread
    设置线程任务（run）：吃包子
    判断包子的状态：
        false：等待
        true:吃包子；吃完；修改包子状态；唤醒生产者线程
测试类（main）：
    创建包子对象；创建包子铺线程；创建吃货线程，开启

public class baozi {
    String pi;
    String xian;
    boolean flag=false;
}

import exception.waitnotifyex.baozi;

/*
注意：
生产者和消费者是互斥的，使用同步技术保证两个线程只能有一个在执行
锁对象必须唯一，使用包子对象作为锁对象
 */
public class baozipu extends Thread{
    public baozi bz;
    public baozipu(baozi bz){
        this.bz=bz;
    }
    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="三鲜馅";
                    //System.out.println("生产包子");
                }
                else{
                    bz.pi="冰皮";
                    bz.xian="肉馅";
                }
                count++;
                System.out.println("生产"+bz.pi+bz.xian+"包子");
                try {
                    sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                bz.flag=true;
                bz.notify();
                System.out.println("生产好了"+bz.pi+bz.xian+"包子");
            }
        }
    }
}

import exception.waitnotifyex.baozi;

public class xiaofeizhe extends Thread{
    public baozi bz;
    public xiaofeizhe(baozi bz){
        this.bz=bz;
    }
    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+"包子，包子铺开始生产");
                System.out.println("------------------------");
            }
        }
    }
}

public class waitnotify {
    public static void main(String[] args) {
        baozi bz=new baozi();
        new baozipu(bz).start();
        new xiaofeizhe(bz).start();
    }
}