导航菜单
路很长,又很短
博主信息
昵   称:Cocodroid ->关于我
Q     Q:2531075716
博文数:338
阅读量:1588371
访问量:166454
至今:
×
云标签 标签球>>
云标签 - Su的技术博客
Tags : 生产者消费者模式,并发发表时间: 2015-10-05 09:59:28

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里,生产者就是生产数据的线程,消费者就是消费数据的线程。在多线程开发当中,如果生产者处理速度很快,而消费者处理速度很慢,那么生产者就必须等待消费者处理完,才能继续生产数据。同样的道理,如果消费者的处理能力大于生产者,那么消费者就必须等待生产者。为了解决这种生产消费能力不均衡的问题,所以便有了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯,而通过阻塞队列来进行通讯,所以生产者生产完数据之后不用等待消费者处理,直接扔给阻塞队列,消费者不找生产者要数据,而是直接从阻塞队列里取,阻塞队列就相当于一个缓冲区,平衡了生产者和消费者的处理能力。

这个阻塞队列就是用来给生产者和消费者解耦的。纵观大多数设计模式,都会找一个第三者出来进行解耦,如工厂模式的第三者是工厂类,模板模式的第三者是模板类。在学习一些设计模式的过程中,如果先找到这个模式的第三者,能帮助我们快速熟悉一个设计模式。

生产者消费者模式实战

我和同事一起利用业余时间开发的Yuna工具中使用了生产者和消费者模式。首先我先介绍下Yuna工具,在阿里巴巴很多同事都喜欢通过邮件分享技术文章,因为通过邮件分享很方便,同学们在网上看到好的技术文章,复制粘贴发送就完成了分享,但是我们发现技术文章不能沉淀下来,对于新来的同学看不到以前分享的技术文章,大家也很难找到以前分享过的技术文章。为了解决这问题,我们开发了Yuna工具。Yuna取名自我非常喜欢的一款RPG游戏”最终幻想”中女主角的名字。

首先我们申请了一个专门用来收集分享邮件的邮箱,比如share@alibaba.com,同学将分享的文章发送到这个邮箱,让同学们每次都抄送到这个邮箱肯定很麻烦,所以我们的做法是将这个邮箱地址放在部门邮件列表里,所以分享的同学只需要象以前一样向整个部门分享文章就行,Yuna工具通过读取邮件服务器里该邮箱的邮件,把所有分享的邮件下载下来,包括邮件的附件,图片,和邮件回复,我们可能会从这个邮箱里下载到一些非分享的文章,所以我们要求分享的邮件标题必须带有一个关键字,比如[内贸技术分享],下载完邮件之后,通过confluence的web service接口,把文章插入到confluence里,这样新同事就可以在confluence里看以前分享过的文章,并且Yuna工具还可以自动把文章进行分类和归档。

为了快速上线该功能,当时我们花了三天业余时间快速开发了Yuna1.0版本。在1.0版本中我并没有使用生产者消费模式,而是使用单线程来处理,因为当时只需要处理我们一个部门的邮件,所以单线程明显够用,整个过程是串行执行的。在一个线程里,程序先抽取全部的邮件,转化为文章对象,然后添加全部的文章,最后删除抽取过的邮件。代码如下:

01 public void extract() {
02         logger.debug("开始" + getExtractorName() + "。。");
03         //抽取邮件
04         List<Article> articles = extractEmail();
05         //添加文章
06         for (Article article : articles) {
07             addArticleOrComment(article);
08         }
09         //清空邮件
10         cleanEmail();
11         logger.debug("完成" + getExtractorName() + "。。");
12     }

Yuna工具在推广后,越来越多的部门使用这个工具,处理的时间越来越慢,Yuna是每隔5分钟进行一次抽取的,而当邮件多的时候一次处理可能就花了几分钟,于是我在Yuna2.0版本里使用了生产者消费者模式来处理邮件,首先生产者线程按一定的规则去邮件系统里抽取邮件,然后存放在阻塞队列里,消费者从阻塞队列里取出文章后插入到conflunce里。代码如下:

01 public class QuickEmailToWikiExtractor extends AbstractExtractor {
02  
03 private ThreadPoolExecutor      threadsPool;
04  
05 private ArticleBlockingQueue<ExchangeEmailShallowDTO> emailQueue;
06  
07 public QuickEmailToWikiExtractor() {
08         emailQueue= new ArticleBlockingQueue<ExchangeEmailShallowDTO>();
09         int corePoolSize = Runtime.getRuntime().availableProcessors() * 2;
10         threadsPool = new ThreadPoolExecutor(corePoolSize, corePoolSize, 10l, TimeUnit.SECONDS,
11                 new LinkedBlockingQueue<Runnable>(2000));
12  
13     }
14  
15 public void extract() {
16         logger.debug("开始" + getExtractorName() + "。。");
17         long start = System.currentTimeMillis();
18  
19         //抽取所有邮件放到队列里
20         new ExtractEmailTask().start();
21  
22         // 把队列里的文章插入到Wiki
23         insertToWiki();
24  
25         long end = System.currentTimeMillis();
26         double cost = (end - start) / 1000;
27         logger.debug("完成" + getExtractorName() + ",花费时间:" + cost + "秒");
28     }
29  
30     /**
31      * 把队列里的文章插入到Wiki
32      */
33     private void insertToWiki() {
34         //登录wiki,每间隔一段时间需要登录一次
35         confluenceService.login(RuleFactory.USER_NAME, RuleFactory.PASSWORD);
36  
37         while (true) {
38             //2秒内取不到就退出
39             ExchangeEmailShallowDTO email = emailQueue.poll(2, TimeUnit.SECONDS);
40             if (email == null) {
41                 break;
42             }
43             threadsPool.submit(new insertToWikiTask(email));
44         }
45     }
46  
47      protected List<Article> extractEmail() {
48         List<ExchangeEmailShallowDTO> allEmails = getEmailService().queryAllEmails();
49         if (allEmails == null) {
50             return null;
51         }
52         for (ExchangeEmailShallowDTO exchangeEmailShallowDTO : allEmails) {
53             emailQueue.offer(exchangeEmailShallowDTO);
54         }
55         return null;
56     }
57  
58     /**
59      * 抽取邮件任务
60      *
61      * @author tengfei.fangtf
62      */
63     public class ExtractEmailTask extends Thread {
64         public void run() {
65             extractEmail();
66         }
67     }
68 }

使用了生产者和消费者模式后,邮件的整体处理速度比以前要快了很多。

多生产者和多消费者场景

在多核时代,多线程并发处理速度比单线程处理速度更快,所以我们可以使用多个线程来生产数据,同样可以使用多个消费线程来消费数据。而更复杂的情况是,消费者消费的数据,有可能需要继续处理,于是消费者处理完数据之后,它又要作为生产者把数据放在新的队列里,交给其他消费者继续处理。如下图:

producer-consumer

我们在一个长连接服务器中使用了这种模式,生产者1负责将所有客户端发送的消息存放在阻塞队列1里,消费者1从队列里读消息,然后通过消息ID进行hash得到N个队列中的一个,然后根据编号将消息存放在到不同的队列里,每个阻塞队列会分配一个线程来消费阻塞队列里的数据。如果消费者2无法消费消息,就将消息再抛回到阻塞队列1中,交给其他消费者处理。

以下是消息总队列的代码;

01 /**
02  * 总消息队列管理
03  *
04  * @author tengfei.fangtf
05  */
06 public class MsgQueueManager implements IMsgQueue{
07  
08     private static final Logger              LOGGER
09  = LoggerFactory.getLogger(MsgQueueManager.class);
10  
11     /**
12      * 消息总队列
13      */
14     public final BlockingQueue<Message> messageQueue;
15  
16     private MsgQueueManager() {
17         messageQueue = new LinkedTransferQueue<Message>();
18     }
19  
20     public void put(Message msg) {
21         try {
22             messageQueue.put(msg);
23         catch (InterruptedException e) {
24             Thread.currentThread().interrupt();
25         }
26     }
27  
28     public Message take() {
29         try {
30             return messageQueue.take();
31         catch (InterruptedException e) {
32             Thread.currentThread().interrupt();
33         }
34         return null;
35     }
36  
37 }

启动一个消息分发线程。在这个线程里子队列自动去总队列里获取消息。

01 /**
02      * 分发消息,负责把消息从大队列塞到小队列里
03      *
04      * @author tengfei.fangtf
05      */
06     static class DispatchMessageTask implements Runnable {
07         @Override
08         public void run() {
09             BlockingQueue<Message> subQueue;
10             for (;;) {
11                 //如果没有数据,则阻塞在这里
12                 Message msg = MsgQueueFactory.getMessageQueue().take();
13                 //如果为空,则表示没有Session机器连接上来,
14 需要等待,直到有Session机器连接上来
15                 while ((subQueue = getInstance().getSubQueue()) == null) {
16                     try {
17                         Thread.sleep(1000);
18                     catch (InterruptedException e) {
19                         Thread.currentThread().interrupt();
20                     }
21                 }
22                 //把消息放到小队列里
23                 try {
24                     subQueue.put(msg);
25                 catch (InterruptedException e) {
26                     Thread.currentThread().interrupt();
27                 }
28             }
29         }
30     }

使用Hash算法获取一个子队列。

01 /**
02      * 均衡获取一个子队列。
03      *
04      * @return
05      */
06     public BlockingQueue<Message> getSubQueue() {
07         int errorCount = 0;
08         for (;;) {
09             if (subMsgQueues.isEmpty()) {
10                 return null;
11             }
12             int index = (int) (System.nanoTime() % subMsgQueues.size());
13             try {
14                 return subMsgQueues.get(index);
15             catch (Exception e) {
16                 //出现错误表示,在获取队列大小之后,队列进行了一次删除操作
17                 LOGGER.error("获取子队列出现错误", e);
18                 if ((++errorCount) < 3) {
19                     continue;
20                 }
21             }
22