场景

一个线程从某个地方接收消息(数据)，可以是其他主机或者消息队列，然后转由另外的一个线程池来执行具体处理消息的逻辑，并且消息的处理速度小于接收消息的速度。这种情景很常见，试想一下，你会怎么设计和实现？

直观想法

很显然采用JUC的线程框架，可以迅速写出代码。

消息接收者：

1. public class Receiver { 
2.     private static volatile boolean inited = false; 
3.     private static volatile boolean shutdown = false; 
4.     private static volatile int cnt = 0; 
5.  
6.     private MessageHandler messageHandler; 
7.  
8.     public void start(){ 
9.         Executors.newSingleThreadExecutor().execute(new Runnable() { 
10.             @Override 
11.             public void run() { 
12.                 while(!shutdown){ 
13.                     init(); 
14.                     recv(); 
15.                 } 
16.             } 
17.         }); 
18.     } 
19.  
20.     /** 
21.      * 模拟消息接收 
22.      */ 
23.     public void recv(){ 
24.             Message msg = new Message("Msg" + System.currentTimeMillis()); System.out.println(String.format("接收到消息(%d): %s", ++cnt, msg)); messageHandler.handle(msg); } public void init(){ if(!inited){ messageHandler = new MessageHandler(); inited = true; } } public static void main(String[] args) { new Receiver().start(); 
25.     } 
26. } 

消息处理：

1. public class MessageHandler { 
2.  
3.     private static final int THREAD_POOL_SIZE = 4; 
4.  
5.     private ExecutorService service = Executors.newFixedThreadPool(THREAD_POOL_SIZE); 
6.  
7.     public void handle(Message msg) { 
8.         try { 
9.             service.execute(new Runnable() { 
10.                 @Override 
11.                 public void run() { 
12.                     parseMsg(msg); 
13.                 } 
14.             }); 
15.         } catch (Throwable e) { 
16.             System.out.println("消息处理异常" + e); } } /** * 比较耗时的消息处理流程 */ public void parseMsg(Message message) { while (true) { try { System.out.println("解析消息：" + message); Thread.sleep(5000); System.out.println("============================"); } catch (InterruptedException e) { 
17.                 e.printStackTrace(); 
18.             } 
19.  
20.         } 
21.     } 
22. }