关闭

生产者/消费者模式(阻塞队列) 一个经典的并发模型

标签: socket并发线程
6052人阅读 评论(0) 收藏 举报
分类:

生产消费者模式也是关于线程阻塞的问题,生产消费者模式是通过观察者模式来实现的。之前在编写一个通讯软件的时候用到了这种模式,通过维护一个BlockingQueue来完成Socket的消息发送,后来读书时看到在服务器开发时三层模型中的Service层在调用Dao层的时候也是通过这种模式来调用的,具体怎么使用的还没有具体实践过,期待后面可以有机会练习这一块。

实际的软件开发过程中,经常会碰到如下场景:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、线程、进程等)。产生数据的模块,就形象地称为生产者;而处理数据的模块,就称为消费者。
 
单单抽象出生产者和消费者,还够不上是生产者/消费者模式。该模式还需要有一个缓冲区处于生产者和消费者之间,作为一个中介。生产者把数据放入缓冲区,而消费者从缓冲区取出数据。

  • 解耦
      假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法,那么生产者对于消费者就会产生依赖(也就是耦合)。将来如果消费者的代码发生变化,可能会影响到生产者。而如果两者都依赖于某个缓冲区,两者之间不直接依赖,耦合也就相应降低了。
      
  • 支持并发(concurrency)
      生产者直接调用消费者的某个方法,还有另一个弊端。由于函数调用是同步的(或者叫阻塞的),在消费者的方法没有返回之前,生产者只好一直等在那边。万一消费者处理数据很慢,生产者就会白白糟蹋大好时光。
      使用了生产者/消费者模式之后,生产者和消费者可以是两个独立的并发主体(常见并发类型有进程和线程两种,后面的帖子会讲两种并发类型下的应用)。生产者把制造出来的数据往缓冲区一丢,就可以再去生产下一个数据。基本上不用依赖消费者的处理速度。其实当初这个模式,主要就是用来处理并发问题的。
      
  • 支持忙闲不均
      缓冲区还有另一个好处。如果制造数据的速度时快时慢,缓冲区的好处就体现出来了。当数据制造快的时候,消费者来不及处理,未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来,消费者再慢慢处理掉。

用了两种方式实现了一下这个模式

1.方法一:

消费者:

public class TestConsumer implements Runnable {
    TestQueue queue;

    public TestConsumer() {
        // TODO Auto-generated constructor stub
    }

    public TestConsumer(TestQueue obj) {
        this.queue = obj;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                queue.consumer();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

    }

}

生产者:

public class TestProduct implements Runnable {
    TestQueue t;

    public TestProduct() {

    }

    public TestProduct(TestQueue t) {
        this.t = t;
    }

    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                t.product("test" + i);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

队列:

public class TestQueue {
    public static Object signal = new Object();
    boolean bFull = false;
    private List thingsList = new ArrayList();

    /**
     * 生产
     * 
     * @param thing
     * @throws Exception
     */
    public void product(String thing) throws Exception {
        synchronized (signal) {
            if (!bFull) {
                bFull = true;
                System.out.println("product");
                thingsList.add(thing);
                signal.notify(); // 然后通知消费者
            }
        }
    }

    /**
     * 消费
     * 
     * @return
     * @throws Exception
     */
    public String consumer() {
        synchronized (signal) {
            if (!bFull) {
                // 队列为空。等待.....
                try {
                    signal.wait();
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } // 进入signal待召队列,等待生产者的通知
            }
            bFull = false;
            // 读取buf 共享资源里面的东西
            System.out.println("consume");
            signal.notify(); // 然后通知生产者
        }
        String result = "";
        if (thingsList.size() > 0) {
            result = thingsList.get(thingsList.size() - 1).toString();
            thingsList.remove(thingsList.size() - 1);
        }
        return result;
    }
}

测试代码:

public class Application {
    @Test
    public void test(){
        TestQueue queue = new TestQueue();
        Thread customer = new Thread(new TestConsumer(queue));
     Thread product = new Thread(new TestProduct(queue));
     customer.start();
     product.start();
    }
}

2.方法二:

使用java.util.concurrent.BlockingQueue类来重写的队列那个类,使用这个方法比较简单。直接看JDK提供的demo

class Producer implements Runnable {  
   private final BlockingQueue queue;  
   Producer(BlockingQueue q) { queue = q; }  
    public void run() {  
      try {  
        while(true) { queue.put(produce()); }  
      } catch (InterruptedException ex) { ... handle ...}  
    }  
    Object produce() { ... }  
  }  

  class Consumer implements Runnable {  
    private final BlockingQueue queue;  
    Consumer(BlockingQueue q) { queue = q; }  
    public void run() {  
      try {  
        while(true) { consume(queue.take()); }  
      } catch (InterruptedException ex) { ... handle ...}  
    }  
    void consume(Object x) { ... }  
  }  

  class Setup {  
    void main() {  
      BlockingQueue q = new SomeQueueImplementation();  
      Producer p = new Producer(q);  
      Consumer c1 = new Consumer(q);  
      Consumer c2 = new Consumer(q);  
      new Thread(p).start();  
      new Thread(c1).start();  
      new Thread(c2).start();  
    }  
 }  

在JDK1.5以上使用了Lock锁来实现:

    class BoundedBuffer {  
      final Lock lock = new ReentrantLock();  
      final Condition notFull  = lock.newCondition();   
      final Condition notEmpty = lock.newCondition();   

      final Object[] items = new Object[100];  
      int putptr, takeptr, count;  

      public void put(Object x) throws InterruptedException {  
        lock.lock();  
        try {  
          while (count == items.length)   
            notFull.await();  
          items[putptr] = x;   
          if (++putptr == items.length) putptr = 0;  
          ++count;  
          notEmpty.signal();  
        } finally {  
          lock.unlock();  
        }  
      }  

      public Object take() throws InterruptedException {  
        lock.lock();  
        try {  
          while (count == 0)   
            notEmpty.await();  
          Object x = items[takeptr];   
          if (++takeptr == items.length) takeptr = 0;  
          --count;  
          notFull.signal();  
          return x;  
        } finally {  
          lock.unlock();  
        }  
      }   
    }  
0
0
查看评论

生产者/消费者模式(阻塞队列)

生产者/消费者模式(阻塞队列) 博客分类:  j2EE 制造thread多线程软件测试JDK  生产消费者模式  貌似也是阻塞的问题  花了一些时间终于弄明白这个鸟东东,以前还以为是不复杂的一个东西的,以前一直以为和观察者模...
  • autumn20080101
  • autumn20080101
  • 2013-07-26 08:48
  • 37965

生产者/消费者模式之深入理解

★简介    在实际的软件开发过程中,经常会碰到如下场景:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、线程、进程等)。产生数据的模块,就形象地称为生产者;而处理数据的模块,就称为消费者。    ...
  • sanyuesan0000
  • sanyuesan0000
  • 2016-11-01 15:52
  • 2443

生产者/消费者模式

[0]:概述 今天打算来介绍一下“生产者/消费者模式”,这玩意儿在很多开发领域都能派上用场。由于该模式很重要,打算分几个帖子来介绍。今天这个帖子先来扫盲一把。如果你对这个模式已经比较了解,请跳过本扫盲帖,直接看下一个帖子(关于该模式的具体应用)。 看到这里,可能有同学心中犯嘀
  • Kaiwii
  • Kaiwii
  • 2011-09-08 09:42
  • 55871

如何实现生产者消费者模式

生产/消费者问题是个非常典型的多线程问题,涉及到的对象包括“生产者”、“消费者”、“仓库”和“产品”。他们之间的关系如下: ① 生产者仅仅在仓储未满时候生产,仓满则停止生产。 ② 消费者仅仅在仓储有产品时候才能消费,仓空则等待。 ③ 当消费者发现仓库没产品可消费时候会通知生产者生产。 ④ 生...
  • u010339647
  • u010339647
  • 2016-07-24 11:33
  • 4230

Kafka下的生产消费者模式与订阅发布模式

生产消费者模式与订阅发布模式是使用消息中间件时常用的两种模式,用于功能解耦和分布式系统间的消息通信。本文在总结了Kafka基本概念的基础上,以“数据接入”和“事件分发”这两个场景为例,来探讨Kafka作为消息系统的应用方法(High Level)。
  • zwgdft
  • zwgdft
  • 2017-01-21 17:27
  • 9454

聊聊并发(十)生产者消费者模式

http://my.oschina.net/xianggao/blog/390411 在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。 为什么要使用生产者和消费者模式 在线程世...
  • liangxw1
  • liangxw1
  • 2016-05-17 13:29
  • 971

生产者-消费者模式

概述 生产者-消费者模式在系统交互方面,有两个特点: 1、系统解耦 2、解决并发问题下面用几个简单例子逐步说明。 简单例子 假设有两个系统,A系统和B系统,B系统需要依赖A系统产生的数据,也就是说,A系统产生数据后,必须把数据扔给B系统。 这个时候,可以让B系统提供一个方法,比如说提供一个...
  • linsongbin1
  • linsongbin1
  • 2017-02-13 14:54
  • 1100

生产者消费者模式浅析

由于最近工作中,涉及到生产者消费者设计模式,对此有一些体会,所以总结一下,与大家分享。什么是生产者消费者模式在工作中,大家可能会碰到这样一种情况:某个模块负责产生数据,这些数据由另一个模块来负责处理(此处的模块是广义的,可以是类、函数、线程、进程等)。产生数据的模块,就形象地称为
  • lenyusun
  • lenyusun
  • 2011-07-15 23:30
  • 16020

基于阻塞队列实现消费者和生产者

本文自己手打,转载注明出处。
  • Richard_vi
  • Richard_vi
  • 2017-03-03 11:12
  • 223

高并发:阻塞队列 实现生产者-消费者模式

首先介绍一下非阻塞队列,比如PriorityQueue、LinkedList。在使用非阻塞队列时遇到的问题:不会对当前线程产生阻塞,在面对类似消费者-生产者的模型时,必须额外地实现同步策略以及线程间唤醒策略,这个实现起来非常麻烦。 所以,阻塞队列恰恰不一样,阻塞队列会对当前线程产生阻塞,比如一个线...
  • g893465244
  • g893465244
  • 2016-09-12 11:32
  • 2580
    个人资料
    • 访问:591199次
    • 积分:7087
    • 等级:
    • 排名:第3837名
    • 原创:168篇
    • 转载:13篇
    • 译文:0篇
    • 评论:100条
    博客专栏
    最新评论