Java设计模式——生产者消费者模式

生产这消费者，自己还是dubbo中听说的。但这其实是一个经典的线程问题。
者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者消费数据。
阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

我这里以wait和notifyAll方法实现。
写的比较简单直接代码了:

package com.storage;



import java.util.LinkedList;

public class Storage {

    //缓冲区
    private final int MAX = 100;//仓库最大存储
    private LinkedList<Object> list = new LinkedList<Object>();

    /**
     *
     * @param 生产方法
     */
    //生产方法，生产产品
    public void produce(String producer){
        synchronized (list) {
            //欢唱仓库是否已满
            while (list.size() == MAX) {
                System.out.println("仓库已满，" + producer + "： 暂时不能执行生产任务!");
                try {
                    list.wait();
                } catch (InterruptedException e) {//阻塞方法收到中断请求
                    e.printStackTrace();
                }
            }
            //生产产品
            list.add(new Object());

            System.out.println(producer+"：生产了一个产品\t【现仓储量为】:" + list.size());

            list.notifyAll();//唤醒线程

        }
    }

    /**
     *
     * @param 消费方法
     */
    //消费方法
    public void consume(String consumer){
        synchronized (list){
                //判断仓库是否为空
            while (list.size() == 0){
                System.out.println("仓库已空，"+consumer+"： 暂时不能执行消费任务!");
                try {
                    list.wait();
                } catch (InterruptedException e) {//阻塞方法收到中断请求
                    e.printStackTrace();
                }
            }

            //消费产品
            list.remove();
            
            System.out.println(consumer+"：消费了一个产品\t【现仓储量为】:" + list.size());
            list.notifyAll();
        }
    }

    public int getMAX() {
        return MAX;
    }

    public LinkedList<Object> getList() {
        return list;
    }

    public void setList(LinkedList<Object> list) {
        this.list = list;
    }
}

测试

package com.storage;

public class test {
    public static void main(String[] args) {
        Storage storage = new Storage();


        //生产方法
        for (int i = 0; i < 5 ; i++) {
            int j = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    storage.produce(String.format("生产者%d:",j));
                }
            }).start();
        }


        //消费方法
        for (int i = 1; i < 4 ;i++){
            int j = i;
            new Thread(new Runnable() {
                @Override
                public void run() {
                    storage.consume(String.format("消费者%d:",j));
                }
            }).start();
        }

    }
}

运行结果
生产者2:：生产了一个产品 【现仓储量为】:1
生产者3:：生产了一个产品 【现仓储量为】:2
生产者0:：生产了一个产品 【现仓储量为】:3
消费者2:：消费了一个产品 【现仓储量为】:2
消费者3:：消费了一个产品 【现仓储量为】:1
消费者1:：消费了一个产品 【现仓储量为】:0
生产者1:：生产了一个产品 【现仓储量为】:1
生产者4:：生产了一个产品 【现仓储量为】:2
参考：
https://blog.csdn.net/shadowcw/article/details/82352829