设计模式--生产者消费者模式

常见场景：

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

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

缓冲区作用

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

2. 支持并发和异步

假设有一食品加工厂，它有一个仓库能存放一定量的食品，工厂不断的生产出食品并存放到仓库中，而消费者不断的从仓库中购买食品。

下面采用数组模拟栈实现该设计模式

1.创建实体类

public class Food {    private int id;    Food(int id){        this.id = id;    }    @Override    public String toString(){        return "第 【" + id + "】个食物";    }}

2.创建仓库类

public class FoodStoreHouse {    private int index = 0;//  使用数组模拟栈    public Food[] foodBuffer  = new Food[5];    public synchronized void push(Food food){        try{            while(index == foodBuffer.length){                this.wait();            }        }catch(InterruptedException e){            e.printStackTrace();        }        foodBuffer[index++] = food;        this.notifyAll();    }    public synchronized Food pop(){        try{//          此处使用while不能使用if，否则当线程被打断时catch后面的会继续执行            while(index == 0){                this.wait();            }        }catch(InterruptedException e){            e.printStackTrace();        }        Food food = foodBuffer[--index];        this.notifyAll();        return food;    }}

3.创建生产者

public class Productor implements Runnable {    private FoodStoreHouse foodHouse;    Productor(FoodStoreHouse foodHouse){        this.foodHouse = foodHouse;    }    @Override    public void run() {        // TODO Auto-generated method stub        try{            product();        }catch(InterruptedException e){            e.printStackTrace();        }    }    private void product() throws InterruptedException{        for(int i=0; i<5; i++){            Food food = new Food(i);            System.out.println(Thread.currentThread().getName() + "正在生产" + food.toString());            foodHouse.push(food);            Thread.sleep((int) (Math.random()*500));        }    }}

4.创建消费者

public class Comsumer implements Runnable{    private FoodStoreHouse foodHouse;    Comsumer(FoodStoreHouse foodHouse){        this.foodHouse = foodHouse;    }    @Override    public void run() {        // TODO Auto-generated method stub        try{            comsume();        }catch(InterruptedException e){            e.printStackTrace();        }    }    private void comsume() throws InterruptedException{        for(int i=0; i<5; i++){            Food food = foodHouse.pop();            System.out.println(Thread.currentThread().getName() +  "---正在消费" + food.toString());            Thread.sleep((int) (Math.random()*1000));        }    }}

5.测试类

public class TestComsumerProductor {    public static void main(String[] args){        FoodStoreHouse foodHouse = new FoodStoreHouse();        Productor p = new Productor(foodHouse);        Comsumer c = new Comsumer(foodHouse);        Thread p1 = new Thread(p);        p1.setName("1号生产者");        Thread p2 = new Thread(p);        p2.setName("2号生产者");        Thread c1 = new Thread(c);        c1.setName("1号消费者");        Thread c2 = new Thread(c);        c2.setName("2号消费者");        p1.start();        p2.start();        c1.start();        c2.start();    }}

6.测试结果

1号生产者正在生产第 【0】个食物2号生产者正在生产第 【0】个食物1号消费者---正在消费第 【0】个食物2号消费者---正在消费第 【0】个食物2号生产者正在生产第 【1】个食物1号生产者正在生产第 【1】个食物2号生产者正在生产第 【2】个食物2号生产者正在生产第 【3】个食物2号生产者正在生产第 【4】个食物1号生产者正在生产第 【2】个食物2号消费者---正在消费第 【4】个食物1号消费者---正在消费第 【2】个食物1号生产者正在生产第 【3】个食物1号消费者---正在消费第 【3】个食物2号消费者---正在消费第 【3】个食物1号生产者正在生产第 【4】个食物1号消费者---正在消费第 【4】个食物2号消费者---正在消费第 【2】个食物1号消费者---正在消费第 【1】个食物2号消费者---正在消费第 【1】个食物

---

下面使用BlockingQueue实现该模式

BlockingQueue即阻塞队列，从阻塞这个词可以看出，在某些情况下对阻塞队列的访问可能会造成阻塞。被阻塞的情况主要有如下两种：

1. 当队列满了的时候进行入队列操作
2. 当队列空了的时候进行出队列操作

因此，当一个线程试图对一个已经满了的队列进行入队列操作时，它将会被阻塞，除非有另一个线程做了出队列操作；同样，当一个线程试图对一个空队列进行出队列操作时，它将会被阻塞，除非有另一个线程进行了入队列操作。

在Java中，BlockingQueue的接口位于java.util.concurrent 包中(在Java5版本开始提供)，由上面介绍的阻塞队列的特性可知，阻塞队列是线程安全的。

BlockingQueue的核心方法：

放入数据：

　　offer(anObject)：表示如果可能的话,将anObject加BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.（本方法不阻塞当前执行方法的线程）
　　
　　offer(E o, long timeout, TimeUnit unit)：可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败。
　　
　　put(anObject)：把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻塞直到BlockingQueue里面有空间再继续。
　　

获取数据：

　　poll(time)：取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null。
　　
　　poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。如果时间超时还没有数据可取，返回失败。
　　
　　take()：取走BlockingQueue里排在首位的对象,若BlockingQueue为空，阻塞该线程直到BlockingQueue有新的数据被加入。
　　
　　drainTo()：一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数）， 通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

使用BlockingQueue的好处:

在多线程环境下，我们每个程序员都必须去自己控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。而使用BolckingQueue，我们不需要关心什么时候需要阻塞线程，什么时候需要唤醒线程。

*下面为实现代码*
　　
1.创建实体类

public class Food {    private int id;    Food(int id){        this.id = id;    }    @Override    public String toString(){        return "第 【" + id + "】个食物";    }}

2.创建生产者

import java.util.concurrent.BlockingQueue;public class Productor implements Runnable {    private BlockingQueue<Food> foodHouse;    Productor(BlockingQueue foodHouse){        this.foodHouse = foodHouse;    }    @Override    public void run() {        // TODO Auto-generated method stub        try{            product();        }catch(InterruptedException e){            e.printStackTrace();        }    }    private void product() throws InterruptedException{        for(int i=0; i<5; i++){            Food food = new Food(i);            System.out.println(Thread.currentThread().getName() + "正在生产" + food.toString());            foodHouse.put(food);            Thread.sleep((int) (Math.random()*500));        }    }}

3.创建消费者

import java.util.concurrent.BlockingQueue;public class Comsumer implements Runnable{    private BlockingQueue<Food> foodHouse;    Comsumer(BlockingQueue foodHouse){        this.foodHouse = foodHouse;    }    @Override    public void run() {        // TODO Auto-generated method stub        try{            comsume();        }catch(InterruptedException e){            e.printStackTrace();        }    }    private void comsume() throws InterruptedException{        for(int i=0; i<5; i++){            Food food = foodHouse.take();            System.out.println(Thread.currentThread().getName() +  "---正在消费" + food.toString());            Thread.sleep((int) (Math.random()*1000));        }    }}

4.测试类

import java.util.concurrent.BlockingQueue;import java.util.concurrent.LinkedBlockingQueue;public class TestComsumerProductor {    public static void main(String[] args){    //  这里使用LinkedBlockingQueue来实现BlockingQueue,也可以选择其他的实现方式        BlockingQueue<Food> foodHouse = new LinkedBlockingQueue<Food>();        Productor p = new Productor(foodHouse);        Comsumer c = new Comsumer(foodHouse);        Thread p1 = new Thread(p);        p1.setName("1号生产者");        Thread p2 = new Thread(p);        p2.setName("2号生产者");        Thread c1 = new Thread(c);        c1.setName("1号消费者");        Thread c2 = new Thread(c);        c2.setName("2号消费者");        p1.start();        p2.start();        c1.start();        c2.start();    }}

5.测试结果

2号生产者正在生产第 【0】个食物1号生产者正在生产第 【0】个食物2号消费者---正在消费第 【0】个食物1号消费者---正在消费第 【0】个食物1号生产者正在生产第 【1】个食物2号生产者正在生产第 【1】个食物1号消费者---正在消费第 【1】个食物2号生产者正在生产第 【2】个食物1号生产者正在生产第 【2】个食物1号生产者正在生产第 【3】个食物1号消费者---正在消费第 【1】个食物2号生产者正在生产第 【3】个食物2号生产者正在生产第 【4】个食物2号消费者---正在消费第 【2】个食物1号生产者正在生产第 【4】个食物1号消费者---正在消费第 【2】个食物2号消费者---正在消费第 【3】个食物2号消费者---正在消费第 【3】个食物1号消费者---正在消费第 【4】个食物2号消费者---正在消费第 【4】个食物