Java中的设计模式(二):生产者-消费者模式与观察者模式-阿里云开发者社区

开发者社区> 开发与运维> 正文
登录阅读全文

Java中的设计模式(二):生产者-消费者模式与观察者模式

简介: 做一个简单的延伸和对比

Java中的设计模式(二):生产者-消费者模式与观察者模式.png

人生苦短,不如养狗

一、前言

  在上一篇 Java中的设计模式(一):观察者模式 中我们了解了 观察者模式 的基本原理和使用场景,在今天的这篇文章中我们要做一点简单的延伸性学习——对比一下 生产者-消费者模式观察者模式 的异同。

二、什么是“生产者-消费者模式”?

  和观察者模式不同,生产者-消费者模式 本身并不属于设计模式中的任何一种 。那么生产者-消费者模式到底是什么呢?下面我们用一个例子简单说明一下:

生产者-消费者模式.jpg

  如同上图中所示,生产者和消费者就如同一本杂志的投稿作者和订阅的读者,同一本杂志的投稿作者可以有多个,它的读者也可以有多个,而杂志就是连接作者和读者的桥梁(即缓冲区)。通过杂志这个数据缓冲区,作者可以将完成的作品投递给订阅了杂志的读者,在这一过程中,作者不用关心读者是否收到了作品或是否完成了阅读,作者和读者是两个相对独立的对象,两者的行为互不影响。

  可以看到,在这个例子当中出现了三个角色,分别是 生产者消费者 以及 缓冲区 。生产者和消费者比较好理解,前者是生产数据,后者则是处理前者生产出来的数据。而缓冲区在生产者-消费者模式中则起到了一个 解耦支持异步支持忙闲不均 的作用。

三、两者的区别

1. 编程范式不同

  生产者-消费者模式和观察者模式的第一个不同点在上面已经说过,前者是一种 面向过程 的软件设计模式,不属于Gang of Four提出的23种设计模式中的任何一种,而后者则是23中设计模式中的一种,也即面向对象的设计模式中的一种。

2. 关联关系不同

  这一理念上的不同就带出了下一种不同点,即观察者模式中只有一对多的关系,没有多对多的关系,而在生产者-消费者模式中则是多对多的关系。

  在观察者模式中,被观察者只有一个,观察者却可以有多个。就比如十字路口的交通灯,直行的车辆只会观察控制直行的交通灯,不会去观察控制左拐或者右拐的交通灯,也就是说观察的对象是固定唯一的。

  而在生产者-消费者模式中则不同,生产者可以有多个,消费者也可以有多个。还是用上面作者和读者的例子,在这个例子当中,读者只关心杂志的内容而不必关心内容的创作者是谁,作者也只需要知道创作完的作品可以发布到对应的杂志,而不必关心会有那些读者。

3. 耦合关系不同

  从上一个不同中不难看出生产者-消费者模式和观察者模式的耦合关系也不相同,前者为 轻耦合 ,后者为 重耦合 。

4. 应用场景不同

  观察者模式多用于 事件驱动模型 当中,生产者-消费者模式则多出现在 进程间通信 ,用于进行解耦和并发处理,我们常用的消息队列用的就是生产者-消费者模式。当然在Java中使用生产者-消费者模式还需要注意缓冲区的线程安全问题,这里就不做过多叙述。

四、一个小例子

  最后用一个简单的demo来结束本次的延伸学习。

1. StoreQueue--缓冲区

public class StoreQueue<T> {
    private final BlockingQueue<T> queue = new LinkedBlockingQueue<>();
    /**
     * 队列中增加数据
     *
     * @param data 生产者生产的数据
     */
    public void add(T data) {
        try {
            queue.put(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    /**
     * 队列中获取数据
     *
     * @return 从队列中获取到的数据
     */
    public T get() {
        try {
            return queue.take();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

  在这个例子中,我们使用了jdk自身的 阻塞队列BlockingQueue 来实现了一个缓冲区,这里只需要实现放数据和取数据的方法。如果我们自己实现一个阻塞队列,一方面需要注意阻塞的处理,另一方面需要考虑线程安全的问题,这里就不展开叙述了,有兴趣的同学可以看下BlockingQueue的源码。

2. Producer--生产者

public class Producer implements Runnable{
    private StoreQueue<String> storeQueue;
    public Producer(StoreQueue<String> storeQueue) {
        this.storeQueue = storeQueue;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            storeQueue.add(Thread.currentThread().getName() + ":" + i);
        }
    }
}

3. Consumer--消费者

public class Consumer implements Runnable{
    private StoreQueue<String> storeQueue;
    public Consumer(StoreQueue<String> storeQueue) {
        this.storeQueue = storeQueue;
    }
    @Override
    public void run() {
        try {
            while (true) {
                String data = storeQueue.get();
                System.out.println("当前消费线程 : " + Thread.currentThread().getName() + ", 接收到数据 : " + data);
            }
        } catch (Exception e) {
            e.printStackTrace();
            Thread.currentThread().interrupt();
        }
    }
}

4. 执行逻辑和运行结果

执行逻辑

public static void main(String[] args) {
        StoreQueue<String> storeQueue = new StoreQueue<>();
        Producer producer = new Producer(storeQueue);
        Consumer consumer = new Consumer(storeQueue);
        Producer producerTwo = new Producer(storeQueue);
        Consumer consumerTwo = new Consumer(storeQueue);
        new Thread(producer).start();
        new Thread(consumer).start();
        new Thread(producerTwo).start();
        new Thread(consumerTwo).start();
    }

运行结果

当前消费线程 : Thread-1, 接收到数据 : Thread-0:0
当前消费线程 : Thread-1, 接收到数据 : Thread-0:1
当前消费线程 : Thread-1, 接收到数据 : Thread-0:2
当前消费线程 : Thread-1, 接收到数据 : Thread-0:3
当前消费线程 : Thread-1, 接收到数据 : Thread-0:4
当前消费线程 : Thread-3, 接收到数据 : Thread-0:5
当前消费线程 : Thread-3, 接收到数据 : Thread-0:7
当前消费线程 : Thread-3, 接收到数据 : Thread-0:8
当前消费线程 : Thread-3, 接收到数据 : Thread-0:9
当前消费线程 : Thread-3, 接收到数据 : Thread-2:0
当前消费线程 : Thread-3, 接收到数据 : Thread-2:1
当前消费线程 : Thread-3, 接收到数据 : Thread-2:2
当前消费线程 : Thread-3, 接收到数据 : Thread-2:3
当前消费线程 : Thread-3, 接收到数据 : Thread-2:4
当前消费线程 : Thread-3, 接收到数据 : Thread-2:5
当前消费线程 : Thread-3, 接收到数据 : Thread-2:6
当前消费线程 : Thread-3, 接收到数据 : Thread-2:7
当前消费线程 : Thread-3, 接收到数据 : Thread-2:8
当前消费线程 : Thread-3, 接收到数据 : Thread-2:9
当前消费线程 : Thread-1, 接收到数据 : Thread-0:6

  可以看到在上面的数据结果中,不同生产者生产的数据只会被一个消费者消费,没有出现线程安全问题,这要归功于实现缓冲区使用到的 BlockingQueue

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章
最新文章
相关文章