生产者与消费者模式的概念、运用、3种实现

生产者与消费者模式的概念、运用、3种实现

本文为笔者的学习整理总结，因此，若有任何不严谨或错误之处，还望不吝指教！

内容：

一、 概念
二、 运用
三、 实现
    1. Sychronized、wait、notify
    2. ReentrantLock
    3. BlockingQueue

一、概念

生产者与消费者模式的核心在于生产者与消费者的关系解藕，生产者与消费者不直接进行通讯和产品交接，而是通过一个阻塞队列，起到一个缓冲区的作用——生产者将生产完成的产品放入阻塞队列，消费者从阻塞队列取。以达到平衡生产者与消费者的处理能力，提高运行效率。

很多程序员都喜欢说自己搬砖，那就以搬砖为例理解，过程先是通过人力把砖搬到砖场或砖堆，然后等待客户整车拉走。那么人力相当于生产者，客户相当于消费者，而这个砖堆/砖场相当于阻塞队列，平衡了人力和汽车搬砖的速率。

当然了，实际运用中，不一定都是如此一个阻塞队列多个消费者多个生产者的构建模式，也有可能是不同的对应关系。因此，具体构建还需要根据现实进行设计，只需要遵循核心——生产者与消费者的关系解藕，通过阻塞队列平衡处理能力。

二、运用

生产者与消费者模式运用广泛，尤其在消息队列的机制，比如订单系统，客户产生订单后，将订单放入订单队列，等待处理；比如公司下各应用各网络节点将运营数据放入消息队列收集，再提供给公司的运营部门查阅；比如 Java 的线程池，程序员将任务丢给线程池，线程池根据当前池里的执行情况，决定进行执行还是进入阻塞队列。

三、实现

以下通过三种方式实现，分别为：

• Synchronized、 wait、 notify
• RetreenLock
• BlockingQueue

1. Synchronized、wait、notify

代码 - java

/**
 * @Author: patrick-mac
 * @Date: 2018/8/31 15:31
 * @Description:
 */
public class ProduceConsumer1 {

    public static void main(String[] args) {
        Resource resource = new Resource();

        ExecutorService executorService = Executors.newFixedThreadPool(10);
        // 4 个生产者
        Thread p1 = new Thread(new Producer(resource, 50));
        Thread p2 = new Thread(new Producer(resource, 30));
        Thread p3 = new Thread(new Producer(resource, 40));
        Thread p4 = new Thread(new Producer(resource, 20));
        // 5 个消费者
        Thread c1 = new Thread(new Consumer(resource, 10));
        Thread c2 = new Thread(new Consumer(resource, 20));
        Thread c3 = new Thread(new Consumer(resource, 20));
        Thread c4 = new Thread(new Consumer(resource, 30));
        Thread c5 = new Thread(new Consumer(resource, 30));

        p1.start();p2.start();p3.start();p4.start();
        c1.start();c2.start();c3.start();c4.start();c5.start();

    }

    /**
     * 模拟阻塞队列
     */
    static class Resource {
        // 队列最大数量
        private int MAX_SIZE = 100;
        // 队列产品
        private LinkedList list = new LinkedList();

        /**
         * 加入资源
         */
        public void add (int num) {
            synchronized (list) {
                System.out.print("【生产数量】：" + num + "，【队列数量】：" +
                        list.size());

                if (list.size() + num > MAX_SIZE) {
                    System.out.println("，任务不执行，队列容量不足");

                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 塞入产品
                for (int i = 0; i < num; ++i) {
                    list.add(new Object());
                }

                System.out.println("，任务执行，更新后【队列数量】：" + list.size());
                list.notifyAll();
            }
        }

        /**
         * 消费资源
         */
        public void remove(int num) {
            synchronized (list) {
                System.out.print("【消费数量】：" + num + "，【队列数量】：" +
                        list.size());

                if (list.size() - num < 0) {
                    System.out.println("，任务不执行，队列数量不足！");

                    try {
                        list.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 取出产品
                for (int i = 0; i < num; ++i) {
                    list.poll();
                }
                System.out.println("，任务执行，更新后【队列数量】：" + list.size());
                list.notifyAll();
            }
        }
    }

    /**
     * 模拟生产者
     */
    static class Producer implements Runnable {
        private Resource resource;
        private int num;

        public Producer(Resource resource, int num) {
            this.resource = resource;
            this.num = num;
        }

        @Override
        public void run() {
            resource.add(num);
        }
    }

    /**
     * 模拟消费者
     */
    static class Consumer implements Runnable {
        private Resource resource;
        private int num;

        public Consumer(Resource resource, int num) {
            this.resource = resource;
            this.num = num;
        }

        @Override
        public void run() {
            resource.remove(num);
        }
    }

}

2. RentrantLock

/**
 * @Author: patrick-mac
 * @Date: 2018/8/31 16:55
 * @Description:
 */
public class ProduceConsumer2 {
    public static void main(String[] args) {

        Lock lock = new ReentrantLock();
        Condition produceCondition = lock.newCondition();
        Condition consumeCondition = lock.newCondition();

        Resource resource = new Resource(lock, produceCondition, consumeCondition);

        // 4 个生产者
        Thread p1 = new Thread(new Producer(resource, 50));
        Thread p2 = new Thread(new Producer(resource, 30));
        Thread p3 = new Thread(new Producer(resource, 40));
        Thread p4 = new Thread(new Producer(resource, 20));
        // 5 个消费者
        Thread c1 = new Thread(new Consumer(resource, 10));
        Thread c2 = new Thread(new Consumer(resource, 20));
        Thread c3 = new Thread(new Consumer(resource, 20));
        Thread c4 = new Thread(new Consumer(resource, 30));
        Thread c5 = new Thread(new Consumer(resource, 30));

        p1.start();p2.start();p3.start();p4.start();
        c1.start();c2.start();c3.start();c4.start();c5.start();

    }

    /**
     * 模拟阻塞队列
     */
    static class Resource {
        // 队列最大数量
        private int MAX_SIZE = 100;
        // 队列产品
        private LinkedList list = new LinkedList();

        private Lock lock;
        private Condition produceCondition;
        private Condition consumeCondition;

        public Resource(Lock lock, Condition condition1, Condition condition2) {
            this.lock = lock;
            this.produceCondition = condition1;
            this.consumeCondition = condition2;
        }

        /**
         * 加入资源
         */
        public void add (int num) {
            lock.lock();
            try {
                while (list.size() + num > MAX_SIZE) {
                    System.out.println("【生产数量】：" + num + "，【队列数量】：" +
                            list.size() + "，任务暂不执行，进入等待！");

                    try {
                        produceCondition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 塞入产品
                for (int i = 0; i < num; ++i) {
                    list.add(new Object());
                }

                System.out.println("【生产数量】：" + num + "，任务执行，更新后【队列数量】：" + list.size());
                consumeCondition.signalAll();
            }
            finally {
                lock.unlock();
            }
        }

        /**
         * 消费资源
         */
        public void remove(int num) {
            lock.lock();
            try {
                while (list.size() - num < 0) {
                    System.out.println("【消费数量】：" + num + "，【队列数量】：" +
                            list.size() + "，任务暂不执行，任务进入等待！");

                    try {
                        consumeCondition.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                // 取出产品
                for (int i = 0; i < num; ++i) {
                    list.poll();
                }
                System.out.println("【消费数量】：" + num + "，任务执行，更新后【队列数量】：" + list.size());
                produceCondition.signalAll();
            }
            finally {
                lock.unlock();
            }
        }
    }

    /**
     * 模拟生产者
     */
    static class Producer implements Runnable {
        private Resource resource;
        private int num;

        public Producer(Resource resource, int num) {
            this.resource = resource;
            this.num = num;
        }

        @Override
        public void run() {
            resource.add(num);
        }
    }

    /**
     * 模拟消费者
     */
    static class Consumer implements Runnable {
        private Resource resource;
        private int num;

        public Consumer(Resource resource, int num) {
            this.resource = resource;
            this.num = num;
        }

        @Override
        public void run() {
            resource.remove(num);
        }
    }
}

3. BlockingQueue

/**
 * @Author: patrick-mac
 * @Date: 2018/9/2 11:21
 * @Description:
 */
public class ProduceConsumer3 {

    public static void main(String[] args) {
        Resource resource = new Resource();

        // 4 个生产者
        Thread p1 = new Thread(new Producer(resource, 50));
        Thread p2 = new Thread(new Producer(resource, 30));
        Thread p3 = new Thread(new Producer(resource, 40));
        Thread p4 = new Thread(new Producer(resource, 20));
        // 5 个消费者
        Thread c1 = new Thread(new Consumer(resource, 10));
        Thread c2 = new Thread(new Consumer(resource, 20));
        Thread c3 = new Thread(new Consumer(resource, 20));
        Thread c4 = new Thread(new Consumer(resource, 30));
        Thread c5 = new Thread(new Consumer(resource, 30));

        p1.start();p2.start();p3.start();p4.start();
        c1.start();c2.start();c3.start();c4.start();c5.start();
    }

    static class Resource {
        final int MAX_SIZE = 100;
        private BlockingQueue que = new ArrayBlockingQueue(MAX_SIZE);

        /**
         * 加入资源
         */
        public void add (int num) {
            try {
                for (int i = 0; i < num; ++i) {
                    que.put(new Object());
                }
                System.out.println("【生产数量】：" + num + "，任务执行，更新后【队列数量】：" + que.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        /**
         * 消费资源
         */
        public void remove(int num) {
            try {
                for (int i = 0; i < num; ++i) {
                    que.take();
                }
                System.out.println("【消费数量】：" + num + "，任务执行，更新后【队列数量】：" + que.size());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 模拟生产者
     */
    static class Producer implements Runnable {
        private Resource resource;
        private int num;

        public Producer(Resource resource, int num) {
            this.resource = resource;
            this.num = num;
        }

        @Override
        public void run() {
            resource.add(num);
        }
    }

    /**
     * 模拟消费者
     */
    static class Consumer implements Runnable {
        private Resource resource;
        private int num;

        public Consumer(Resource resource, int num) {
            this.resource = resource;
            this.num = num;
        }

        @Override
        public void run() {
            resource.remove(num);
        }
    }
}