生产者消费者--吃包子场景

多个生产者和多个消费者各自都是以异步的方式运行
但是在某些情况写，生产者和消费者之间必须保持同步：

• 当缓冲区空的时候，不允许消费者到缓冲区中取数据
• 当缓冲区满的时候，不允许生产者向缓冲区中放入数据
• 同时缓冲区中的一个单元，只能放入一个产品

方式一

public class Test {
    public static void main(String[] args) {
        //创建一个蒸笼对象
        Container container = new Container();
        //同一个锁对象，即同一个蒸笼
        Produce produce = new Produce(container);
        Consumer consumer = new Consumer(container);
        //开始在线程中执行任务，四个线程互斥
        new Thread(produce,"做包子的1").start();
        new Thread(produce,"做包子的2").start();
        new Thread(consumer,"吃包子的1").start();
        new Thread(consumer,"吃包子的2").start();
        /*
        阻塞：做包子的2、吃包子的1、吃包子的2
            随机唤醒

            为什么多个生产者线程，和多消费者线程的时候，此时，会出现“卡死的情况”？
                假设现在，其他3个线程都 因为wait()方法处于阻塞状态，且只有做包子的1线程正在执行
                假设现在蒸笼没有包子（只有做包子才会出现通知别人）
                1.做包子的1线程，看了下蒸笼为空，做包子，并通知别人，假设用notify选择的是做包子的2线程来执行
                2.做包子的2线程被唤醒，执行，看了下有包子，做包子的2线程阻塞自己
                3.现在只有做包子的1线程，开始执行吗，发现有包子阻塞自己
        */
    }
}

• 生产者，任务是做包子

public class Produce implements Runnable{

    //代表做包子的，要放包子的蒸笼（一个缓冲区，可作为锁对象）
    private Container container;

    private Food[] foodBill = {new Food("杭州小笼包",1),
                                new Food("狗不理",10),
                                new Food("豆沙包",2),
                                new Food("生煎",3)};

    public Produce(Container container) {//蒸笼进行构造函数，可使生产者和消费者拥有共同的锁对象
        this.container = container;
    }

    @Override
    public void run() {
        //首先判断蒸笼中是否有包子
        while (true){
            synchronized (container){
                if (!container.isEmpty()){
                    //如果有包子，就克制自己wait()
                    try {
                        //让当前状态阻塞
                        container.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{//不能省，多线程中，可能出现还会调用做包子的

                    //如果没有包子，并将包子放入蒸笼
                    //随机做一个包子，并将包子放入蒸笼
                    Random random = new Random();
                    int foodIndex = random.nextInt(foodBill.length);//从几种包子中选择一个放进去
                    //把随机选择的包子（通过随机选择包子的下标），放入蒸笼
                    container.setFood(foodBill[foodIndex]);

                    如果没有包子，做包子，同时通知吃包子的
                    container.notifyAll();
                }
            }
        }
    }
}

• 消费者，任务是吃包子

public class Consumer implements Runnable{

    private Container container;

    public Consumer(Container container) {
        this.container = container;
    }

    @Override
    public void run() {
        while (true){
            //首先判断蒸笼中有没有包子
            synchronized (container){
                if(container.isEmpty()){
                    //如果说蒸笼中没有包子，阻止自己wait()
                    try {
                        //让当前线程处于阻塞
                        container.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else {
                    //如果说，蒸笼中有包子，吃包子，同时通知做包子的人做包子
                    //吃包子
                    container.eatFood();

                    //通知做包子的
                    container.notifyAll();
                }
            }
        }
    }
}

• 表示蒸笼类

public class Container {
        //笼中包子
        private Food food;

        //做包子，放包子
    public void setFood(Food food){
        System.out.println(Thread.currentThread().getName()+"做了"+food);
        this.food = food;
    }
        //把包子从蒸笼中拿出来吃
    public void eatFood() {
        System.out.println(Thread.currentThread().getName()+"吃了"+food);
        food = null;
    }
        //判断蒸笼是否为空
    public boolean isEmpty(){
        return food == null;
    }
}

• 表示包子类

class Food{
    private String name;
    private int price;

    public Food(String name, int price) {
        this.name = name;
        this.price = price;
    }
    @Override
    public String toString() {
        return "Food{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

方式二–改进

蒸笼是，智能蒸笼

1. 生产者和消费者线程，线程同步，蒸笼来完成
2. 阻止自己，通知别人，也是由蒸笼来完成

public class Container {
    //蒸笼
    private Food food;

   /*
      做包子的做好包子，向蒸笼中放包子

      明确:  该方法，在生产者线程中被调用，所以被生产者线程调用时，运行在生产者线程中
   */
   public synchronized void setFood(Food food){//需要什么样包子，传参
        if (this.food != null){
            try {
                //生产者阻止自己，进入阻塞
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName() + "做了" + food);
            this.food = food;//改变当前的包子


            this.notifyAll();//当前线程做好通知吃包子的人
        }
   }
   /*
      把包子，丛蒸笼中拿出来吃

       明确:  该方法，在消费者线程中被调用，所以被生产者线程调用时，运行在消费者线程中
   */
   public synchronized void eatFood(){//直接吃掉当前已经做好的包子，只有一个，不用传参
       if (this.food == null){
           try {
               this.wait();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }else {
           System.out.println(Thread.currentThread().getName() + "吃了" + food);
           this.food = null;

           this.notifyAll();//当前线程吃好通知做包子的人
       }
   }
}
class Food{
    private String name;
    private int price;

    public Food(String name, int price) {
        this.name = name;
        this.price = price;
    }

    @Override
    public String toString() {
        return "Food{" +
                "name='" + name + '\'' +
                ", price=" + price +
                '}';
    }
}

• 生产者

public class Producer implements Runnable{

    /*
       代表做包子的，要放入包子的蒸笼
    */
    Container container;

    private Food[] foodBill = {new Food("杭州小笼包", 1),
            new Food("狗不理", 10),
            new Food("豆沙包", 2),
            new Food("生煎包", 3)};
    private Random random;

    public Producer(Container container) {
        this.container = container;
        random = new Random(foodBill.length );
    }

    @Override
    public void run() {

        while (true) {
            int indexOfFood = random.nextInt(foodBill.length);
            container.setFood(foodBill[indexOfFood]);
        }
    }
}

• 消费者

public class Consumer implements Runnable{
    private Container container;

    public Consumer(Container container) {
        this.container = container;
    }

    @Override
    public void run() {
        while (true){
            container.eatFood();
        }
    }
}