Java多线程与并发——生产者与消费者应用案例

多线程的开发中有一个最经典的操作案例，就是生产者-消费者，生产者不断生产产品，消费者不断取走产品。

package com.vince;
/**
 * 生产者与消费者案例
 * @author Administrator
 *
 */
public class ThreadDemo4 {


    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Food food=new Food();
        Producter p=new Producter(food);
        Customer c=new Customer(food);
        Thread t1=new Thread(p);
        Thread t2=new Thread(c);
        t1.start();
        t2.start();
    }

}
//生产者
class Producter implements Runnable{
    private Food food;
    public Producter(Food food){
        this.food=food;
    }
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        for(int i=0;i<50;i++){
            if(i%2==0){
                /*food.setName("银耳莲子汤");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
                food.setEfficasy("美容养颜");*/
                food.set("银耳莲子汤", "美容养颜");
            }else{
                /*food.setName("水煮肉片");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
                food.setEfficasy("增肥");*/
                food.set("水煮肉片", "增肥");
            }
        }
    }
    
}
//消费者
class Customer implements Runnable{
    private Food food;
    public Customer(Food food){
        this.food=food;
    }
    @Override
    public void run() {
        // TODO 自动生成的方法存根
        for(int i=0;i<50;i++){
            food.get();
        }
    }
    
}
//消费的对象(数据)
class Food{
    private String name;//菜名
    private String efficasy;//功效
    
    private boolean flag=true;//true表示可以生产不能消费，false表示可以消费
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getEfficasy() {
        return efficasy;
    }
    public void setEfficasy(String efficasy) {
        this.efficasy = efficasy;
    }
    public Food(String name, String efficasy) {
        super();
        this.name = name;
        this.efficasy = efficasy;
    }
    public Food() {
        super();
        // TODO 自动生成的构造函数存根
    }
    //生产产品
    public synchronized void set(String name,String efficasy){
        //表示不能生产
        if(!flag){
            try {
                this.wait();//当前线程进入等待状态，让出CPU，并释放该监视器上的锁。
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
        this.setName(name);
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        this.setEfficasy(efficasy);
        flag=false;//表示不能再生产
        this.notify();//唤醒该监视器上的其它一个线程
    }
    public synchronized void get(){
        if(flag){
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO 自动生成的 catch 块
                e.printStackTrace();
            }
        }
        
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }
        System.out.println(this.getName()+"->"+this.getEfficasy());
        flag= true;//表示不能再消费
        this.notify();//唤醒该监视器上的其它一个线程
    }
}