线程间的通信

1.线程间的通信：多个线程处理同一个资源，但处理的动作却不同

2.线程间的有效通信：使用等待唤醒机制，实现协调通信，让线程间进行有规律的执行

3.条件：3.1 wait方法与notify方法必须由同一个锁对象调用，因为，对应的锁对象可以通过notify唤醒使用同一个对象调用的wait方法后的线程
          3.2 wait与notify是属于object类的方法，因为，锁可以是任意对象，而任意对象的所属类，都是继承object类的
          3.3 wait与notify必须要在同步代码块或者同步函数中使用，因为，必须通过锁对象调用这2个方法
4.以吃货和包子铺做包子为例子：
                线程A：包子铺线程
                线程B：吃货线程
                共同资源：包子
                规律的执行：如果包子没有，那么包子铺线程要被唤醒做包子，吃货进行无限等待
                            如果包子有了，那么吃货要被唤醒起来吃包子，包子铺线程无限等待

案例如下：

package thread.communication;

/**创建包子类，封装包子的相关信息
 * @author Jeady
 * @Date 2019/8/1
 */
public class Baozi {

    String pi;
    String xian;

    boolean status = false;

    public String getPi() {
        return pi;
    }

    public void setPi(String pi) {
        this.pi = pi;
    }

    public String getXian() {
        return xian;
    }

    public void setXian(String xian) {
        this.xian = xian;
    }

    public boolean isStatus() {
        return status;
    }

    public void setStatus(boolean status) {
        this.status = status;
    }
}

 

package thread.communication;

/**创建包子铺线程
 * @author Jeady
 * @Date 2019/8/1
 */
public class Baozipu extends Thread{

    Baozi baozi;

    public Baozipu(String name,Baozi baozi) {
        super(name);
        this.baozi = baozi;
    }

    @Override
    public void run() {

        //没有包子，包子铺生产包子，吃货等待
            while (true){
                synchronized (baozi){
                    if (baozi.status == true){

                        try {
                            baozi.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    //注意这里是不可以用else的，当if条件满足的时候，我们还要继续往下执行
                    //有包子，包子铺等待，吃货吃包子
                    System.out.println(getName()+"包子铺开始生产包子了");
                    baozi.pi= "皮薄";
                    baozi.xian = "肉馅儿";
                    System.out.println("包子铺把包子生产好了，改变包子状态为有，并唤醒吃货");
                    baozi.status = true;
                    baozi.notify();
                }
            }

    }
}

package thread.communication;

/**创建吃货线程
 * @author Jeady
 * @Date 2019/8/1
 */
public class Chihuo extends Thread{
    Baozi baozi;

    public Chihuo(String name,Baozi baozi) {
        super(name);
        this.baozi = baozi;
    }

    @Override
    public void run() {
        //没有包子，吃货等待，包子铺唤醒做包子
        while (true){
            synchronized (baozi){
                if (baozi.status == false){
                    try {
                        baozi.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(getName()+"开始吃包子"+baozi.pi+baozi.xian);
                System.out.println("包子吃完了，改变包子状态为没有包子，并唤醒包子铺生产包子");
                baozi.status = false;
                baozi.notify();
            }

        }
    }
}

package thread.communication;

/**进行测试
 * @author Jeady
 * @Date 2019/8/1
 */
public class Test01 {

    public static void main(String[] args) {
        Baozi baozi = new Baozi();

        Baozipu baozipu = new Baozipu("包子铺",baozi);
        baozipu.start();

        Chihuo chihuo = new Chihuo("吃货",baozi);
        chihuo.start();
    }
}

执行结果如下：