牛奶发酵剂奶酪，设计生产系统

题目描述如下：

有一家生产奶酪的厂家，每天需要生产100000份奶酪卖给超市，通过一辆送货车发货，送货车辆每次送100份。
厂家有一个容量为1000份的冷库，用于奶酪保鲜，生产的奶酪需要先存放在冷库，运输车辆从冷库取货。
厂家有三条生产线，分别是牛奶供应生产线，发酵剂制作生产线，奶酪生产线。生产每份奶酪需要2份牛奶和1份发酵剂。
请设计生产系统。

根据以下要求，我们可以考虑这么几个方面

• 牛奶生产和发酵剂生产作为生产者，奶酪生产作为消费者
• 奶酪生产作为生产者，货车发车作为消费者
• 牛奶存储和发酵剂存储以及奶酪存储，使用3个阻塞队列暂存
• 货车装车从奶酪队列里每取一百次发一次车
• 一共4个生产者，2个消费者，3个阻塞队列

下面是代码实现

import com.google.common.util.concurrent.ThreadFactoryBuilder;

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 生产奶酪
 *
 * @author since
 * @date 2020-11-02 16:04
 **/
public class Cheese {

    /**
     * 每天生产奶酪的总量
     */
    private static final Integer TOTAL_PRODUCTION = 100000;

    /**
     * 牛奶的数量-200000/天
     */
    private static final AtomicInteger MILK_SIZE = new AtomicInteger(0);

    /**
     * 发酵剂的数量-100000/天
     */
    private static final AtomicInteger STARTER_SIZE = new AtomicInteger(0);

    /**
     * 奶酪的数量-100000/天
     */
    private static final AtomicInteger CHEESE_SIZE = new AtomicInteger(0);

    /**
     * 取奶酪的次数
     */
    private static final AtomicInteger CHEESE_TAKE_TIMES = new AtomicInteger(0);


    /**
     * 阻塞队列，用于存放奶酪，生产者是牛奶和发酵剂，消费者是货车发货，每次发100份
     */
    private static final BlockingQueue<Integer> CHEESE_QUEUE = new LinkedBlockingQueue<>(1000);

    /**
     * 阻塞队列，用于存放生产的牛奶，生产者是牛奶，消费者是奶酪生产
     */
    private static final BlockingQueue<Integer> MILK_QUEUE = new LinkedBlockingQueue<>(2);

    /**
     * 阻塞队列，用于存放生产的发酵剂，生产者是发酵剂，消费者是奶酪生产
     */
    private static final BlockingQueue<Integer> STARTER_QUEUE = new LinkedBlockingQueue<>(1);

    /**
     * 奶酪生产线程池
     */
    private static final ThreadPoolExecutor CHEESE_PRODUCER = new ThreadPoolExecutor(1, 2, 1, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1), new ThreadFactoryBuilder().setNameFormat("cheese-producer-%d").build(), (r, executor) -> System.out.println("Cheese Reject Task"));

    /**
     * 发酵剂生产线程池
     */
    private static final ThreadPoolExecutor STARTER_PRODUCER = new ThreadPoolExecutor(1, 2, 1, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1), new ThreadFactoryBuilder().setNameFormat("starter-producer-%d").build(), (r, executor) -> System.out.println("Starter Reject Task"));

    /**
     * 牛奶生产线程池
     */
    private static final ThreadPoolExecutor MILK_PRODUCER = new ThreadPoolExecutor(1, 2, 1, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1), new ThreadFactoryBuilder().setNameFormat("milk-producer-%d").build(), (r, executor) -> System.out.println("Milk Reject Task"));

    /**
     * 货车发货线程池
     */
    private static final ThreadPoolExecutor TRUCKING = new ThreadPoolExecutor(5, 10, 1, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(1), new ThreadFactoryBuilder().setNameFormat("trucking-%d").build(), (r, executor) -> System.out.println("Trunking Reject Task"));


    /**
     * 奶酪生产线程
     */
    static class CheeseProducer implements Runnable {

        @Override
        public void run() {
            while (CHEESE_SIZE.get() < TOTAL_PRODUCTION) {
                try {
                    //发酵剂取1
                    STARTER_QUEUE.take();
                    //System.out.println("生产奶酪，发酵剂取1");

                    //牛奶取2
                    MILK_QUEUE.take();
                    MILK_QUEUE.take();

                    //System.out.println("生产奶酪，发酵剂取2");

                    //奶酪生产1
                    CHEESE_QUEUE.put(1);
                    //System.out.println("生产1份奶酪");

                    //生产数量加1
                    int i = CHEESE_SIZE.incrementAndGet();

                    if (CHEESE_SIZE.get() == TOTAL_PRODUCTION) {
                        System.out.println("本日奶酪已生产完，共" + i + "份");
                    }


                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * 发酵剂生产线程
     */
    static class StarterProducer implements Runnable {

        @Override
        public void run() {
            while (STARTER_SIZE.get() < TOTAL_PRODUCTION) {
                try {
                    STARTER_QUEUE.put(1);
                    //System.out.println("生产1份发酵剂");
                    //发酵剂+1
                    int i = STARTER_SIZE.incrementAndGet();
                    if (STARTER_SIZE.get() == TOTAL_PRODUCTION) {
                        System.out.println("本日发酵剂已生产完，共" + i + "份");
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }


        }
    }

    /**
     * 牛奶生产线程
     */
    static class MilkProducer implements Runnable {

        @Override
        public void run() {
            while (MILK_SIZE.get() < TOTAL_PRODUCTION * 2) {
                try {
                    MILK_QUEUE.put(1);
                    //System.out.println("生产1份牛奶");

                    //牛奶数量+1
                    int i = MILK_SIZE.incrementAndGet();
                    if (MILK_SIZE.get() == TOTAL_PRODUCTION * 2) {
                        System.out.println("本日牛奶已生产完，共" + i + "份");
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }

    /**
     * 货车发货线程
     */
    static class Trucking implements Runnable {
        @Override
        public void run() {

            while (true) {
                try {
                    //取奶酪装车准备发货
                    CHEESE_QUEUE.take();

                    int i1 = CHEESE_TAKE_TIMES.incrementAndGet();

                    if (i1 % 100 == 0) {
                        System.out.println("货车装满100份，发车");
                    }

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }

        }
    }

    public static void main(String[] args) {
        CHEESE_PRODUCER.execute(new CheeseProducer());

        STARTER_PRODUCER.execute(new StarterProducer());

        MILK_PRODUCER.execute(new MilkProducer());

        TRUCKING.execute(new Trucking());

        while (true) {
            if (CHEESE_SIZE.get() == TOTAL_PRODUCTION) {
                MILK_PRODUCER.shutdown();
                STARTER_PRODUCER.shutdown();
                CHEESE_PRODUCER.shutdown();
                TRUCKING.shutdown();
                System.exit(0);
            }

        }
    }

}

如上代码就是一个典型的生产者消费者代码，而且都是单线程生产和消费。

• 1份奶酪需要2份牛奶和1份发酵剂，确定了2个生产者和一个消费者。
• 货车从冷库里取奶酪，奶酪需要放在冷库里，确定了一个生产者和一个消费者
• 题目要求的所有的生产和消费行为都是单线程的

我自己在实现的时候，从冷库取奶酪的时候，使用了5个线程从冷库里取奶酪，这样会导致在计算取多少次的时候，会导致数据打印出来会乱序。

题目要求的是每100份奶酪发一次车，所以需要在冷库里取100次，下面如果不加锁，会有问题，导致乱序

所以货车如果改成多线程，下面这几行代码需要加锁保证顺序

  CHEESE_QUEUE.take();

  int i1 = CHEESE_TAKE_TIMES.incrementAndGet();

  if (i1 % 100 == 0) {
        System.out.println("货车装满100份，发车");
  }