生产者消费者

生产者消费者模式是一个十分经典的多线程协作的模式，

    // 生产者步骤：
    //  1 判断桌子上是否有汉堡包
    //  如果有就等待，如果没有才生产
    // 2 把汉堡包放在桌子上。
    // 3 叫醒等待待的消费者开吃。

// 消费者
// 1 判断桌上是否有汉堡包
// 2  如果没有就等待
// 3  如果有就开吃
// 4  吃完后，桌子上的汉堡包就没有了，叫醒等待的生产者继续生产
// 汉堡包的总数减去一

package thredDemo14;

public class Cooker extends Thread{
    
    private Desk desk;

    public Cooker(Desk desk){
        this.desk = desk;
    }
    
    // 生产者步骤：
    //  1 判断桌子上是否有汉堡包
    //  如果有就等待，如果没有才生产
    // 2 把汉堡包放在桌子上。
    // 3 叫醒等待待的消费者开吃。
    
    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()) {
                if (desk.getCount() == 0){
                    break;
                }else{
                    if (!desk.isFlag()){
                        // 生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount()+1);
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                    
                }
            }
        }
    }

}
 

package thredDemo14;

public class Foodie extends Thread{
// 消费者
// 1 判断桌上是否有汉堡包
// 2  如果没有就等待
// 3  如果有就开吃
// 4  吃完后，桌子上的汉堡包就没有了，叫醒等待的生产者继续生产
// 汉堡包的总数减去一
private Desk desk;

public Foodie(Desk desk){
    this.desk = desk;
}
    
    
@Override
public void run() {
    // TODO Auto-generated method stub
   while(true){
       synchronized (desk.getLock()) {
           if (desk.getCount() == 0){
               break;
           }else{
               if(desk.isFlag()){
                   // 有
                   System.out.println("吃货在吃汉堡包");
                   desk.setFlag(false);
                   desk.getLock().notifyAll();
                   desk.setCount(desk.getCount()-1);
               }
               
               try {
                desk.getLock().wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
           }
        
    }
   }
}
}
 

package thredDemo14;

public class Desk {
     
    // 定义一个标记
    // true  就表示桌子上有汉堡包的，此时允许吃货执行
    // false 表示桌子上没有汉堡包的，此时允许厨师执行
    
    //public static boolean flag = false;
    
    // 汉堡包的总数
//    public static int count = 10;
    
    // 锁对象
//    public static final Object  lock = new Object();
    
    private boolean flag;
    
    private int count = 10;
    
    private final Object lock = new Object();
    

    public Desk() {
        
    }

    public Desk(boolean flag, int count) {
        
        this.flag = flag;
        this.count = count;
    }

    @Override
    public String toString() {
        return "Desk [flag=" + flag + ", count=" + count + ", lock=" + lock
                + "]";
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }
    
    
} 
 

package thredDemo14;

public class Demo {
    
    // 生产者步骤：
    //  1 判断桌子上是否有汉堡包
    //  如果有就等待，如果没有才生产
    // 2 把汉堡包放在桌子上。
    // 3 叫醒等待待的消费者开吃。
    
    // 消费者
    // 1 判断桌上是否有汉堡包
    // 2  如果没有就等待
    // 3  如果有就开吃
    // 4  吃完后，桌子上的汉堡包就没有了，叫醒等待的生产者继续生产
    // 汉堡包的总数减去一
      public static void main(String[] args){
          
          Desk desk = new Desk();

          Foodie f = new Foodie(desk);
          Cooker c = new Cooker(desk);
          
          f.start();
          c.start();
      }
}