并发框架Disruptor几个Demo

扫盲：

要想了解Disruptor框架必需多花点时间研究下它的工作原理，不然代码是没法撸的！！！

关于Disruptor的详细资料及原理请细看!!!    http://ifeve.com/disruptor/

 

Disruptor版本： 3.2.1

 

名词解释

消费者==事件处理器

 

 

一、现在你必须明白以下问题：

1、你必须明白Ringbuffer是什么，它的数据结构是怎么样的，有什么约定，为什么高效，它的职责是什么。

2、ConsumerBarrier （ifeve网上的译文版本比较早，这个类在2.0.0之后就一直被改名，3.2.1的版本中它是SequenceBarrier）它的职责是什么。

 

Disruptor框架在2.0版本之后不再采用生产者、消费者模型来编写API，而是使用事件模型，其实只是接口设计、类名和概念上的变化，内部原理其实还是一样的。

 

DEMO 一、使用原生API创建一个简单的生产者和消费者

 

Java代码  

1. //DEMO中使用的 消息全假定是一条交易  
2. public class TradeTransaction {  
3.     private String id;//交易ID  
4.     private double price;//交易金额  
5.       
6.     public TradeTransaction() {  
7.     }  
8.     public TradeTransaction(String id, double price) {  
9.         super();  
10.         this.id = id;  
11.         this.price = price;  
12.     }  
13.     public String getId() {  
14.         return id;  
15.     }  
16.     public void setId(String id) {  
17.         this.id = id;  
18.     }  
19.     public double getPrice() {  
20.         return price;  
21.     }  
22.     public void setPrice(double price) {  
23.         this.price = price;  
24.     }  
25. }  
26.   
27. public class TradeTransactionInDBHandler implements EventHandler<TradeTransaction>,WorkHandler<TradeTransaction> {  
28.   
29.     @Override  
30.     public void onEvent(TradeTransaction event, long sequence,  
31.             boolean endOfBatch) throws Exception {  
32.         this.onEvent(event);  
33.     }  
34.   
35.     @Override  
36.     public void onEvent(TradeTransaction event) throws Exception {  
37.         //这里做具体的消费逻辑  
38.         event.setId(UUID.randomUUID().toString());//简单生成下ID  
39.         System.out.println(event.getId());  
40.     }  
41. }  
42.   
43.   
44.   
45. public class Demo1 {  
46.     public static void main(String[] args) throws InterruptedException, ExecutionException {  
47.         int BUFFER_SIZE=1024;  
48.         int THREAD_NUMBERS=4;  
49.         /* 
50.          * createSingleProducer创建一个单生产者的RingBuffer， 
51.          * 第一个参数叫EventFactory，从名字上理解就是“事件工厂”，其实它的职责就是产生数据填充RingBuffer的区块。 
52.          * 第二个参数是RingBuffer的大小，它必须是2的指数倍 目的是为了将求模运算转为&运算提高效率 
53.          * 第三个参数是RingBuffer的生产都在没有可用区块的时候(可能是消费者（或者说是事件处理器） 太慢了)的等待策略 
54.          */  
55.         final RingBuffer<TradeTransaction> ringBuffer = RingBuffer.createSingleProducer(new EventFactory<TradeTransaction>() {  
56.             @Override  
57.             public TradeTransaction newInstance() {  
58.                 return new TradeTransaction();  
59.             }  
60.         }, BUFFER_SIZE,new YieldingWaitStrategy());  
61.         //创建线程池  
62.         ExecutorService executors = Executors.newFixedThreadPool(THREAD_NUMBERS);  
63.         //创建SequenceBarrier  
64.         SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();  
65.           
66.         //创建消息处理器  
67.         BatchEventProcessor<TradeTransaction> transProcessor = new BatchEventProcessor<TradeTransaction>(  
68.                 ringBuffer, sequenceBarrier, new TradeTransactionInDBHandler());  
69.           
70.         //这一部的目的是让RingBuffer根据消费者的状态    如果只有一个消费者的情况可以省略  
71.         ringBuffer.addGatingSequences(transProcessor.getSequence());  
72.           
73.         //把消息处理器提交到线程池  
74.         executors.submit(transProcessor);  
75.         //如果存大多个消费者 那重复执行上面3行代码 把TradeTransactionInDBHandler换成其它消费者类  
76.           
77.         Future<?> future=executors.submit(new Callable<Void>() {  
78.             @Override  
79.             public Void call() throws Exception {  
80.                 long seq;  
81.                 for(int i=0;i<1000;i++){  
82.                     seq=ringBuffer.next();//占个坑 --ringBuffer一个可用区块  
83.                       
84.                     ringBuffer.get(seq).setPrice(Math.random()*9999);//给这个区块放入 数据  如果此处不理解，想想RingBuffer的结构图  
85.                       
86.                     ringBuffer.publish(seq);//发布这个区块的数据使handler(consumer)可见  
87.                 }  
88.                 return null;  
89.             }  
90.         });  
91.         future.get();//等待生产者结束  
92.         Thread.sleep(1000);//等上1秒，等消费都处理完成  
93.         transProcessor.halt();//通知事件(或者说消息)处理器 可以结束了（并不是马上结束!!!）  
94.         executors.shutdown();//终止线程  
95.     }  
96. }  

 

 DEMO二、使用WorkerPool辅助创建消费者

Java代码  

1. public class Demo2 {  
2.     public static void main(String[] args) throws InterruptedException {  
3.         int BUFFER_SIZE=1024;  
4.         int THREAD_NUMBERS=4;  
5.         EventFactory<TradeTransaction> eventFactory=new EventFactory<TradeTransaction>() {  
6.             public TradeTransaction newInstance() {  
7.                 return new TradeTransaction();  
8.             }  
9.         };  
10.         RingBuffer<TradeTransaction> ringBuffer=RingBuffer.createSingleProducer(eventFactory, BUFFER_SIZE);  
11.           
12.         SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();  
13.           
14.         ExecutorService executor = Executors.newFixedThreadPool(THREAD_NUMBERS);  
15.           
16.         WorkHandler<TradeTransaction> workHandlers=new TradeTransactionInDBHandler();  
17.         /* 
18.          * 这个类代码很简单的，亲自己看哈！~ 
19.          */  
20.         WorkerPool<TradeTransaction> workerPool=new WorkerPool<TradeTransaction>(ringBuffer, sequenceBarrier, new IgnoreExceptionHandler(), workHandlers);  
21.           
22.         workerPool.start(executor);  
23.           
24.         //下面这个生产8个数据，图简单就写到主线程算了  
25.         for(int i=0;i<8;i++){  
26.             long seq=ringBuffer.next();  
27.             ringBuffer.get(seq).setPrice(Math.random()*9999);  
28.             ringBuffer.publish(seq);  
29.         }  
30.           
31.         Thread.sleep(1000);  
32.         workerPool.halt();  
33.         executor.shutdown();  
34.     }  
35. }  

 DEMO三、demo3写个流弊点的像下图这样。这次用Disruptor来完成整个构建工作.

从中图可以看出需求是介样子的：生产者生产数据经过C1,C2处理完成后再到C3。

假设如下场景：

1、交易网关收到交易(P1)把交易数据发到RingBuffer中，

2、负责处理增值业务的消费者C1和负责数据存储的消费者C2负责处理交易

3、负责发送JMS消息的消费者C3在C1和C2处理完成后再进行处理。

 

让代码说话：

Java代码  

1. public class TradeTransactionJMSNotifyHandler implements EventHandler<TradeTransaction> {  
2.   
3.     @Override  
4.     public void onEvent(TradeTransaction event, long sequence,  
5.             boolean endOfBatch) throws Exception {  
6.         //do send jms message  
7.     }  
8. }  
9.   
10.   
11.   
12. public class TradeTransactionPublisher implements Runnable{  
13.     Disruptor<TradeTransaction> disruptor;  
14.     private CountDownLatch latch;  
15.     private static int LOOP=10000000;//模拟一千万次交易的发生  
16.   
17.     public TradeTransactionPublisher(CountDownLatch latch,Disruptor<TradeTransaction> disruptor) {  
18.         this.disruptor=disruptor;  
19.         this.latch=latch;  
20.     }  
21.   
22.     @Override  
23.     public void run() {  
24.         TradeTransactionEventTranslator tradeTransloator=new TradeTransactionEventTranslator();  
25.         for(int i=0;i<LOOP;i++){  
26.             disruptor.publishEvent(tradeTransloator);  
27.         }  
28.         latch.countDown();  
29.     }  
30.       
31. }  
32.   
33. class TradeTransactionEventTranslator implements EventTranslator<TradeTransaction>{  
34.     private Random random=new Random();  
35.     @Override  
36.     public void translateTo(TradeTransaction event, long sequence) {  
37.         this.generateTradeTransaction(event);  
38.     }  
39.     private TradeTransaction generateTradeTransaction(TradeTransaction trade){  
40.         trade.setPrice(random.nextDouble()*9999);  
41.         return trade;  
42.     }  
43. }  
44.   
45.   
46. public class TradeTransactionVasConsumer implements EventHandler<TradeTransaction> {  
47.   
48.     @Override  
49.     public void onEvent(TradeTransaction event, long sequence,  
50.             boolean endOfBatch) throws Exception {  
51.         //do something....  
52.     }  
53.       
54. }  
55.   
56.   
57.   
58. public class Demo3 {  
59.     public static void main(String[] args) throws InterruptedException {  
60.         long beginTime=System.currentTimeMillis();  
61.           
62.         int bufferSize=1024;  
63.         ExecutorService executor=Executors.newFixedThreadPool(4);  
64.         //这个构造函数参数，相信你在了解上面2个demo之后就看下就明白了，不解释了~  
65.         Disruptor<TradeTransaction> disruptor=new Disruptor<TradeTransaction>(new EventFactory<TradeTransaction>() {  
66.             @Override  
67.             public TradeTransaction newInstance() {  
68.                 return new TradeTransaction();  
69.             }  
70.         }, bufferSize, executor, ProducerType.SINGLE, new BusySpinWaitStrategy());  
71.           
72.         //使用disruptor创建消费者组C1,C2  
73.         EventHandlerGroup<TradeTransaction> handlerGroup=disruptor.handleEventsWith(new TradeTransactionVasConsumer(),new TradeTransactionInDBHandler());  
74.           
75.         TradeTransactionJMSNotifyHandler jmsConsumer=new TradeTransactionJMSNotifyHandler();  
76.         //声明在C1,C2完事之后执行JMS消息发送操作 也就是流程走到C3  
77.         handlerGroup.then(jmsConsumer);  
78.           
79.           
80.         disruptor.start();//启动  
81.         CountDownLatch latch=new CountDownLatch(1);  
82.         //生产者准备  
83.         executor.submit(new TradeTransactionPublisher(latch, disruptor));  
84.         latch.await();//等待生产者完事.  
85.         disruptor.shutdown();  
86.         executor.shutdown();  
87.           
88.         System.out.println("总耗时:"+(System.currentTimeMillis()-beginTime));  
89.     }  
90. }