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

最新推荐文章于 2024-08-21 20:09:41 发布

Laichilueng

最新推荐文章于 2024-08-21 20:09:41 发布

阅读量759

点赞数 1

分类专栏： Java 设计模式文章标签：设计模式生产者消费者并发异步 java

本文链接：https://blog.csdn.net/laichilueng/article/details/77053936

版权

Java 同时被 2 个专栏收录

6 篇文章 0 订阅

订阅专栏

设计模式

1 篇文章 0 订阅

订阅专栏

常见场景：

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

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

缓冲区作用

解耦，生产者和消费者只依赖缓冲区，而不互相依赖
支持并发和异步

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

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

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

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

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

在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】个食物