生产者消费者模式

过多的同步方法可能造成死锁，避免死锁的方法：

生产者消费者模式

信号灯法：

#notify 和 wait 方法需同synchronized一起使用

public class ProCusApp {


public static void main(String[] args) {

Food foods = new Food(); //共同的资源

//多个线程
Productor pro = new Productor(foods);
Customer cus = new Customer(foods);

Thread productor = new Thread(pro);
Thread customer = new Thread(cus);

productor.start();
customer.start();
}
}


/**
 * 一个场景 共同的资源
 * 生产者消费者模式：信号灯法
 * wait 等待 释放锁 sleep 不释放锁
 * notify/notifyAll:唤醒
 * wait / notify 和 synchronized一起使用
 * @author Kermit
 *
 */
class Food{

private String food;

//flag = T 生产者生产，消费者等待，生产完后提醒消费，生产停止
//flag = F 消费者消费，生产者等待，消费完后提醒生产，消费停止
private boolean flag = true;

public synchronized void productFood(String foods)
{
if(!flag){//生产者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}

try {//开始生产
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}

this.food = foods;
System.out.println("生产了：" + food); //生产完成
this.notify();                      //提醒消费
this.flag = !this.flag;             //停止生产

}

public synchronized void customFood()
{
if(flag){//消费者等待
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}

}

try {//开始消费
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("消费了："+food);//消费完成
this.notify();          //提醒生产
this.flag = !this.flag; //停止消费
}
}

class Productor implements Runnable{

private Food food;

public Productor(Food food) {
super();
this.food = food;
}

@Override
public void run() {
for(int i=0;i<20;i++){
if(0 == i%2){
food.productFood("苹果" + i);
} else {
food.productFood("香蕉" + i);
}
}
}
}


class Customer implements Runnable{

private Food food;

public Customer(Food food) {
super();
this.food = food;
}

@Override
public void run() {
for(int i=0;i<20;i++){
food.customFood();
}
}

}

#原创文章，请勿转载！！