并发框架Disruptor几个Demo

转载 2015年12月01日 19:14:42

声明:转自http://xsh5324.iteye.com/blog/2058925?utm_source=tool.lu

扫盲:

要想了解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. }  

Disruptor多个消费者独立处理生产者消息的简单demo

第一步:创建一个实体类用于封装对象: package Disruptor; public class TradeTransaction { private String id;//交易ID ...

disruptor demo(三) 复杂一点的例子

从中图可以看出需求是介样子的:生产者生产数据经过C1,C2处理完成后再到C3。 假设如下场景: 1、交易网关收到交易(P1)把交易数据发到RingBuffer中, 2、负责处理增值业...

disruptor使用示例

LMAX 开源了一个高性能并发编程框架。可以理解为消费者-生产者的消息发布订阅模式。本文下载了官方示例代码,进行实验。 longEvent事件数据 public class LongEvent { ...
  • wh0426
  • wh0426
  • 2015年05月15日 19:28
  • 1791

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

如何使用 Disruptor(三)写入 Ringbuffer

本文的重点是:不要让 Ring 重叠;如何通知消费者;生产者一端的批处理;以及多个生产者如何协同工作。 AD: 这是 Disruptor 全方位解析(end-to-...

Disruptor 详解

转自:http://www.cnblogs.com/jony-zhang/p/3817208.html 想了解一个项目,最好的办法就是,把它的源码搞到本地自己捣鼓。   在网上看了 N 多人...

Disruptor原理与编程实践

1.Disruptor的背景  disruptor是LAMX架构的一种设计,而LAMX是一种新型的零售金融交易平台。disruptor主要用于大规模低延迟的高并发业务场景,其核心disruptor是一...

Disruptor 详解

想了解一个项目,最好的办法就是,把它的源码搞到本地自己捣鼓。   在网上看了 N 多人对 Disruptor 速度的吹捧,M 多人对它的机制分析,就连 Disruptor 官方文档中,也 ...
  • fishmai
  • fishmai
  • 2016年07月19日 11:05
  • 784

简单使用Disruptor

1.定义事件与事件工厂        事件(Event)就是通过 Disruptor 进行交换的数据类型。        事件工厂(Event Factory)定义了如何实例化事件(Event),...

Disruptor多个消费者不重复处理生产者发送的消息的demo

上一篇介绍的一个生产者向ringbuffer发送了10条消息,每个消费者都会把这个10个消息消费一遍,但是我们还有一种需求就是要让多个消费者不重复消费消息,下面这个简单demo实现了此功能: 创建一...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:并发框架Disruptor几个Demo
举报原因:
原因补充:

(最多只允许输入30个字)