图解Disruptor框架(二):核心概念

图解Disruptor框架(二):核心概念

概述

上一个章节简单的介绍了了下Disruptor,这节就是要好好的理清楚Disruptor中的核心的概念。并且会给出个HelloWorld的小例子。
在正式开始之前,我觉得有一点我感触非常的深刻,那就是:外国人取的类名真的真的非常的合适以及形象!看看接下来的内容就知道了!

核心概念介绍

下面这张图,非常好的总结了Disruptor中需要了解的核心概念:

多生产者多消费者模型
多生产者多消费者模型

  • RingBuffer: Disruptor中的数据结构,用于存储生产者生产的数据(在Disruptor中,叫做Event)。

  • Sequence:序号。在Disruptor框架中,任何地方都有序号。生产者生产的数据放在RingBuffer中的哪个位置,消费者应该消费哪个位置的数据,RingBuffer中的某个位置的数据是什么,这些都是由这个序号来决定的。这个序号可以简单的理解为一个AtomicLong类型的变量。其使用了padding的方法去消除缓存的伪共享问题。

  • Sequencer:序号生成器。这个类主要是用来协调生产者的。在生产者生产数据的时候,Sequencer会产生一个可用的序号(Sequence),然后生产者就乖乖的把数据放在那里了。(此处不严谨,后续会说明原因。)

  • SequencerBarrier:序号屏障。(我觉得这个名字真的太形象了!)我们都知道,消费者在消费数据的时候,需要知道消费哪个位置的数据。消费者总不能自己想取哪个数据消费,就取哪个数据消费吧。(这样多混乱啊!)这个SequencerBarrier起到的就是这样一个“栅栏”般的阻隔作用。你消费者想消费数据,得,我告诉你一个序号(Sequence),你去消费那个位置上的数据。要是没有数据,就好好等着吧(怎么等也是有讲究的)。

先小结一下:Sequence、Sequencer、SequencerBarrier这三个概念一开始我是比较难以理解的。但是总结一下,无非就是Ringbuffer中哪里都需要用到序号,而Sequencer用于生产者生产的时候产生序号,SeqencerBarrier就是协调生产者与消费者,并且告诉消费者一个可以用于消费的序号!

  • Wait Strategy:等待策略。设想一种这样的情景:生产者生产的非常慢,而消费者消费的非常快。那么必然会出现数据不够的情况,这个时候消费者怎么进行等待呢?WaitStrategy就是为了解决问题而诞生的。

  • Event:数据、事件。这个Event就是我们希望RingBuffer存储的数据类型。这个是我们用户自己定义的。我们可以定义为任何事情,比如处理订单、消息等等。

  • EventHandler:事件处理器。当RingBuffer中有数据的时候,消费者怎么去对数据进行处理,就是由这个类去决定的。

  • Producer:生产者。用于生产数据。

上述就是Disruptor框架中的核心概念。如果不是非常的理解,可以先跟着我下面的例子去手敲一遍入门的程序,去体验一下。然后看看源码加深理解。

第一个入门小程序

首先是订单类Order

  1.  
  2. @Data 
  3. public class Order { 
  4.  
  5. /** 
  6. * 订单ID 
  7. */ 
  8. private String id; 
  9.  
  10. /** 
  11. * 订单名字 
  12. */ 
  13. private String name; 
  14.  
  15. /** 
  16. * 用于记录这个对象创建的时间 
  17. */ 
  18. private Date createTime; 
  19. } 
  20.  

订单工厂类OrderFactory。

  1. public class OrderFactory implements EventFactory<Order> { 
  2. public Order newInstance() { 
  3. Order order = new Order(); 
  4. order.setCreateTime(new Date()); 
  5. return order; 
  6. } 
  7. } 

这个类主要用于ringbuffer构造的时候对其中存放的数据进行预加载。
相应的源码如下面所示:

  1.  
  2. /** 
  3. * 用于构造的时候需加载数据 
  4. * @param eventFactory 
  5. */ 
  6. private void fill(EventFactory<E> eventFactory) 
  7. { 
  8. for (int i = 0; i < bufferSize; i++) 
  9. { 
  10. // entries数组就是ringbuffer中用于存放数据的数组 
  11. entries[BUFFER_PAD + i] = eventFactory.newInstance(); 
  12. } 
  13. } 

生产者Producer

  1.  
  2. public class Producer { 
  3.  
  4. private RingBuffer<Order> ringBuffer; 
  5.  
  6.  
  7. public Producer(RingBuffer<Order> ringBuffer) { 
  8. this.ringBuffer = ringBuffer; 
  9. } 
  10.  
  11. public void sendData(String s) { 
  12. long sequence = ringBuffer.next(); 
  13. Order order = ringBuffer.get(sequence); 
  14. order.setId(s); 
  15. ringBuffer.publish(sequence); 
  16. } 
  17. } 

消费者Comsumer

  1.  
  2. @Data 
  3. public class Comsumer implements WorkHandler<Order> { 
  4.  
  5. /** 
  6. * 消费者ID 
  7. */ 
  8. private String comsumerId; 
  9.  
  10. /** 
  11. * 记录消费的次数 
  12. */ 
  13. public static final AtomicInteger count = new AtomicInteger(0); 
  14.  
  15.  
  16. public Comsumer(String comsumerId) { 
  17. this.comsumerId = comsumerId; 
  18. } 
  19.  
  20. @Override 
  21. public void onEvent(Order event) throws Exception { 
  22. System.out.println("消费者:"+comsumerId+"消费了数据,ID="+event.getId()+"Name="+event.getName()); 
  23. count.incrementAndGet(); 
  24. } 
  25. } 

主函数Main

  1.  
  2. public class Main { 
  3. public static void main(String[] args) throws InterruptedException { 
  4.  
  5. // 构造ringbuffer 
  6. RingBuffer<Order> ringBuffer = RingBuffer.create( 
  7. ProducerType.MULTI, 
  8. new OrderFactory(), 
  9. 1024*1024, 
  10. new BlockingWaitStrategy() 
  11. ); 
  12.  
  13. // 创建一个序号屏障 
  14. SequenceBarrier barrier = ringBuffer.newBarrier(); 
  15.  
  16. // 创建消费者数组 
  17. Comsumer[] comsumers = new Comsumer[10]; 
  18. for (int i = 0; i < comsumers.length; i++) { 
  19. comsumers[i] = new Comsumer("comsumer"+i); 
  20. } 
  21.  
  22. // 创建多消费者的工作池 
  23. WorkerPool<Order> workerPool = new WorkerPool<Order>( 
  24. ringBuffer, 
  25. barrier, 
  26. new EventExceptionHandler(), 
  27. comsumers 
  28. ); 
  29.  
  30. // 设置多个消费者的sequence序号 用于单独统计消费进度, 并且设置到ringbuffer中 
  31. ringBuffer.addGatingSequences(workerPool.getWorkerSequences()); 
  32.  
  33. workerPool.start(Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())); 
  34.  
  35. // -----消费者创建完毕----- 
  36.  
  37.  
  38. // -----创建生产者------ 
  39. // 用于阻塞生产者生产数据 
  40. CountDownLatch latch = new CountDownLatch(1); 
  41.  
  42. for(int i = 0; i < 100; i++) { 
  43. final Producer producer = new Producer(ringBuffer); 
  44. new Thread(new Runnable() { 
  45. public void run() { 
  46. try { 
  47. // 阻塞生产者 
  48. latch.await(); 
  49. } catch (Exception e) { 
  50. e.printStackTrace(); 
  51. } 
  52. for(int j = 0; j<100; j++) { 
  53. producer.sendData(UUID.randomUUID().toString()); 
  54. } 
  55. } 
  56. }).start(); 
  57. } 
  58.  
  59. System.err.println("----------线程创建完毕,开始生产数据----------"); 
  60. // 放行生产者,让其生产数据 
  61. latch.countDown(); 
  62.  
  63. // 等待消费者消费完数据 
  64. Thread.sleep(2000); 
  65.  
  66. System.err.println("消费次数:"+Comsumer.count); 
  67.  
  68. } 
  69.  
  70. static class EventExceptionHandler implements ExceptionHandler<Order> { 
  71. public void handleEventException(Throwable ex, long sequence, Order event) { 
  72. } 
  73.  
  74. public void handleOnStartException(Throwable ex) { 
  75. } 
  76.  
  77. public void handleOnShutdownException(Throwable ex) { 
  78. } 
  79. } 
  80. } 

运行结果:
运行结果

上述的代码主要就是生产者生产了10000个数据,然后消费者再消费这些数据。可以看到结果是正确的。

上述这个小小的demo就结束了。接下来会再看看Disruptor的操作,例如链式操作、菱形操作、多边形操作等等。

总结

这一个小节,阐述了Disruptor中的一些核心概念,并编写了一个helloworld程序。如果读者觉得还是比较难理解,那就多敲几遍。这个没有办法的。
项目源码地址: https://gitee.com/cjh95/disruptor_blog/tree/master

参考资料

  1. 官网的简单介绍 https://github.com/LMAX-Exchange/disruptor/wiki/Introduction
  2. 伪共享 https://www.cnblogs.com/cyfonly/p/5800758.html
posted @ 2018-12-19 21:58  Umyng  阅读(567)  评论(0)    收藏  举报