多线程等待唤醒机制之生产消费者模式

　　上篇楼主说明了多线程中死锁产生的原因并抛出问题——死锁的解放方案，那么在本篇文章，楼主将引用一个KFC生产汉堡，顾客购买汉堡的过程来说明死锁解决方案及多线程的等待唤醒机制。

简单地用一幅图来说明KFC生产汉堡，顾客来消费的过程：

场景分析：

1. 资源类：Hamburger   
2. 设置汉堡数据:SetThread(生产者)
3. 获取汉堡数据：GetThread(消费者)
4. 测试类:HamburgerTest
5. 不同种类的线程（生产者、消费者）针对同一资源（汉堡）的操作
6. 当汉堡有存货的时候，汉堡师傅不再生产，顾客可消费；反之，汉堡师傅生产，顾客不可消费
7. 是否有线程安全问题？当然。楼主在《线程安全问题》那篇文章给出了判定方式，在该场景全部满足。

代码构建：类里面的i属性是楼主为了效果好一些特意加的，与本文要说明的问题无关；

　　首先是资源类Hamburger.java，楼主这里为了模拟只简单的构造了3个字段，其中flag用来表示资源是否有数据。

package com.jon.hamburger;

public class Hamburger {
    private String name;//汉堡名称
    private double price;//汉堡价格
    private boolean flag;//汉堡是否有数据的标志，默认为false，表示没有数据
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public boolean isFlag() {
        return flag;
    }
    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    
}

　　接着是生产者SetThread.java与GetThread.java，都需要实现Runnable接口。场景分析中的第7点已经说明，场景存在线程安全的问题，楼主在前篇文章已经说明，线程安全的问题可以通过加锁来进行解决，但是这里涉及到不同种类的线程，所以必须要满足2点：

1. 不同种类的线程都要加锁
2. 不同种类的线程加的锁必须是同一把

SetThread.java

package com.jon.hamburger;

public class SetThread implements Runnable {
    private Hamburger hamburger;
    private int i;

    public SetThread(Hamburger hamburger) {
        this.hamburger = hamburger;
    }
    @Override
    public void run() {
        while (true) {//为了数据效果好一些，楼主加入了判断
            synchronized (hamburger) {
                if(this.hamburger.isFlag()){//如果有存货
                    try {
                        hamburger.wait();//线程等待
                    } catch (InterruptedException e) {                        
                        e.printStackTrace();
                    }
                }
                //如果没有存货，这模拟生产
                if (i % 2 == 0) {
                    this.hamburger.setPrice(25.0);
                    this.hamburger.setName("俊锅的汉堡");
                } else {
                    this.hamburger.setPrice(26.0);
                    this.hamburger.setName("大俊锅的汉堡");
                }
                this.hamburger.setFlag(true);//生产完成后更改标志
                hamburger.notify();//唤醒当前等待的线程
                i++;//只为数据效果好一些，无实际意义
            }

        }

    }

}

GetThread.java

package com.jon.hamburger;

public class GetThread implements Runnable {

    private Hamburger hamburger;
    /**
     * 为了让同步锁使用同一个对象锁，这里通过构造方法进行传递
     * @param hamburger
     */
    public GetThread(Hamburger hamburger){
        this.hamburger = hamburger;
    }
    @Override
    public void run() {
        while(true){
            synchronized (hamburger) {
                if(!this.hamburger.isFlag()){//如果没有存货，线程等待
                    try {
                        hamburger.wait();
                    } catch (InterruptedException e) {                        
                        e.printStackTrace();
                    }
                }
                //如果有数据则进行输出
                System.out.println(this.hamburger.getName()+"-----"+this.hamburger.getPrice());
                this.hamburger.setFlag(false);//更改标志
                hamburger.notify();//唤醒线程
            }    
        }        
        
    }

}

 　　可以看到两个线程类的run方法中都使用了sysnchronized进行了加锁，并使用同一个hamburger对象锁。

　　再看测试类HamburgerTest.java及输出：

package com.jon.hamburger;



public class HamburgerTest {


    public static void main(String[] args) {
        Hamburger hamburger = new Hamburger();
        
        SetThread st = new SetThread(hamburger);//通过构造方法传入共享资源数据hamburger
        GetThread gt = new GetThread(hamburger);
        
        Thread td1 = new Thread(st);
        Thread td2 = new Thread(gt);
        
        td1.start();
        td2.start();

    }

}

　　测试类中，我们通过构造方法给SetThread和GetThread传入了同一个对象，以保证锁对象为同一把。

　　输出结果，线程间不相互影响，同时都无NULL------0.0的情况输出：

　　

俊锅的汉堡-----25.0
大俊锅的汉堡-----26.0
俊锅的汉堡-----25.0
大俊锅的汉堡-----26.0
俊锅的汉堡-----25.0
大俊锅的汉堡-----26.0
俊锅的汉堡-----25.0
大俊锅的汉堡-----26.0

代码分析：

　　我们假设线程t2先抢到CPU的执行权，那么程序执行流程可用下图表示：

　　根据程序代码分析也可见，由于线程之间相互等待产生的死锁问题也得以解决，解决方案就是通过唤醒。另外，文本楼主还使用了另一种方式，思路也差不多，示例代码与本文的示例代码放在一起，已上传到GitHub。

　　本文示例代码地址：https://github.com/LJunChina/JavaResource  中的Hamburger