設計模式-生產者消費者模式

常見場景：

某個模塊負責產生數據，這些數據由另一個模塊來負責處理。產生數據的模塊，就形象地稱為生產者；而處理數據的模塊，就稱為消費者。

該模式還需要有一個緩沖區處於生產者和消費者之間，作為一個中介。生產者把數據放入緩沖區，而消費者從緩沖區取出數據

 

緩沖區作用

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;
    }
}