设计模式-生产者消费者模式 常见场景： 某个模块负责产生数据，这些数据由另一个模块来负责处理。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。 该模式还需要有一个缓冲区处于生

常见场景：

某个模块负责产生数据，这些数据由另一个模块来负责处理。产生数据的模块，就形象地称为生产者；而处理数据的模块，就称为消费者。

该模式还需要有一个缓冲区处于生产者和消费者之间，作为一个中介。生产者把数据放入缓冲区，而消费者从缓冲区取出数据

 

缓冲区作用

1. 解耦，生产者和消费者只依赖缓冲区，而不互相依赖

2. 支持并发和异步

 

方式一，同步队列

/** * 生产者、消费者缓冲区 */public class Storage implements IStorage {    private final int maxSize = 10;    private Queue<Object> queue = new LinkedList<Object>();    @Override    public void put(Object obj) {        synchronized (queue) {            while (queue.size() > maxSize) {                System.out.println("缓冲区已满，不能进入");                try {                    queue.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            queue.add(obj);            System.out.println("进入缓冲区");            queue.notifyAll();        }    }    @Override    public Object get() {        Object obj = null;        synchronized (queue) {            while (queue.size() <= 0) {                System.out.println("缓冲区为空, 进入等待");                try {                    queue.wait();                } catch (InterruptedException e) {                    e.printStackTrace();                }            }            obj = queue.poll();            System.out.println("离开缓冲区");            queue.notifyAll();        }        return obj;    }}

 

 

方式二，可重入锁

public class Storage implements IStorage {    private final int maxSize = 20;    private LinkedList<Object> list = new LinkedList<Object>();    private final Lock lock = new ReentrantLock();    // 仓库满的条件变量    private final Condition full = lock.newCondition();    // 仓库空的条件变量    private final Condition empty = lock.newCondition();    @Override    public void put(Object obj) {        lock.lock();        while (list.size() >= maxSize) {            try {                System.out.println("缓冲区已满，不能进入");                // 生产阻塞                full.await();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        list.add(obj);        System.out.println("进入缓冲区");        empty.signalAll();        lock.unlock();    }    @Override    public Object get() {        lock.lock();        while (list.size() <= 0) {            try {                System.out.println("缓冲区为空, 进入等待");                // 消费阻塞                empty.await();            } catch (InterruptedException e) {                e.printStackTrace();            }        }        Object obj = list.remove();        System.out.println("离开缓冲区");        full.signalAll();        lock.unlock();        return obj;    }}

 

 

方式三，阻塞队列

public class Storage implements IStorage {    private LinkedBlockingQueue<Object> list = new LinkedBlockingQueue<Object>(10);    @Override    public void put(Object obj) {        try {            list.put(obj);        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("进入缓冲区");    }    @Override    public Object get() {        Object obj = null;        try {            obj = list.take();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("离开缓冲区");        return obj;    }}