并发编程之Disruptor

Love The Way You Lie 2022-10-07 00:50 205阅读 0赞

## 1. 简介 ##

Disruptor是英国外汇交易公司LMAX开发的一个高性能队列，研发的初衷是解决内存队列的延迟问题（在性能测试中发现竟然与I/O操作处于同样的数量级）。基于Disruptor开发的系统单线程能支撑每秒600万订单，2010年在QCon演讲后，获得了业界关注。

## 2. Java内置队列 ##

<table> 
 <thead> 
  <tr> 
   <th>队列</th> 
   <th>有界性</th> 
   <th>是否加锁</th> 
   <th>数据结构</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ArrayBlockingQueue</td> 
   <td>bounded</td> 
   <td>加锁</td> 
   <td>arraylist</td> 
  </tr> 
  <tr> 
   <td>LinkedBlockingQueue</td> 
   <td>optionally-bounded</td> 
   <td>加锁</td> 
   <td>linkedlist</td> 
  </tr> 
  <tr> 
   <td>ConcurrentLinkedQueue</td> 
   <td>unbounded</td> 
   <td>无锁</td> 
   <td>linkedlist</td> 
  </tr> 
  <tr> 
   <td>LinkedTransferQueue</td> 
   <td>unbounded</td> 
   <td>无锁</td> 
   <td>linkedlist</td> 
  </tr> 
  <tr> 
   <td>PriorityBlockingQueue</td> 
   <td>unbounded</td> 
   <td>加锁</td> 
   <td>heap</td> 
  </tr> 
  <tr> 
   <td>DelayQueue</td> 
   <td>unbounded</td> 
   <td>加锁</td> 
   <td>heap</td> 
  </tr> 
 </tbody> 
</table>

## 3. Disruptor设计原理 ##

*  **环形数组结构**：为了避免垃圾回收，采用数组而非链表。同时，数组对处理器的缓存机制更加友好。（CPU加载空间局部性原则）
 *  **元素位置定位**：数组长度2^n，通过位运算，加快定位的速度。下标采取递增的形式。不用担心index溢出的问题。index是long类型，即使100万QPS的处理速度，也需要30万年才能用完。
 *  **无锁设计**：每个生产者或者消费者线程，会先申请可以操作的元素在数组中的位置，申请到之后，直接在该位置写入或者读取数据。整个过程通过原子变量CAS，保证操作的线程安全。

#### 3.1 数据结构 ####

框架使用**RingBuffer**来作为队列的数据结构，RingBuffer就是一个可自定义大小的环形数组。

除数组外还有一个**序列号(sequence)**，用以指向下一个可用的元素，供生产者与消费者使用。

原理图如下所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70]  
Sequence mark：Disruptor通过顺序递增的序号来编号管理通过其进行交换的数据（事件），对数据(事件)的处理过程总是沿着序号逐个递增处理。

#### 3.2 组件及作用 ####

1.  **RingBuffer**：Disruptor底层数据结构实现，核心类，是线程间交换数据的中转地
2.  **Sequencer**：序号管理器，生产同步的实现者，负责消费者/生产者各自序号、序号栅栏的管理和协调,Sequencer有单生产者,多生产者两种不同的模式,里面实现了各种同步的算法
3.  **Sequence**：序号，声明一个序号，用于跟踪ringbuffer中任务的变化和消费者的消费情况，disruptor里面大部分的并发代码都是通过对Sequence的值同步修改实现的,而非锁,这是disruptor高性能的一个主要原因
4.  **SequenceBarrier**：序号栅栏，管理和协调生产者的游标序号和各个消费者的序号，确保生产者不会覆盖消费者未来得及处理的消息，确保存在依赖的消费者之间能够按照正确的顺序处理， Sequence Barrier是由Sequencer创建的,并被Processor持有
5.  **EventProcessor**：事件处理器，监听RingBuffer的事件，并消费可用事件，从RingBuffer读取的事件会交由实际的生产者实现类来消费；它会一直侦听下一个可用的序号，直到该序号对应的事件已经准备好
6.  **EventHandler**：业务处理器，是实际消费者的接口，完成具体的业务逻辑实现，第三方实现该接口；代表着消费者
7.  **Producer**：生产者接口，第三方线程充当该角色，producer向RingBuffer写入事件
8.  **Wait Strategy**：Wait Strategy决定了一个消费者怎么等待生产者将事件（Event）放入Disruptor中

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 1]

#### 3.3 等待策略 ####

**① BlockingWaitStrategy** ：

Disruptor的默认策略是BlockingWaitStrategy。在BlockingWaitStrategy内部是使用锁和condition来控制线程的唤醒。BlockingWaitStrategy是最低效的策略，但其对CPU的消耗最小并且在各种不同部署环境中能提供更加一致的性能表现。

**② SleepingWaitStrategy**

SleepingWaitStrategy 的性能表现跟 BlockingWaitStrategy 差不多，对 CPU 的消耗也类似，但其对生产者线程的影响最小，通过使用LockSupport.parkNanos(1)来实现循环等待。一般来说Linux系统会暂停一个线程约60µs，这样做的好处是，生产线程不需要采取任何其他行动就可以增加适当的计数器，也不需要花费时间信号通知条件变量。但是，在生产者线程和使用者线程之间移动事件的平均延迟会更高。它在不需要低延迟并且对生产线程的影响较小的情况最好。一个常见的用例是异步日志记录。

**③ YieldingWaitStrategy**

YieldingWaitStrategy是可以使用在低延迟系统的策略之一。YieldingWaitStrategy将自旋以等待序列增加到适当的值。在循环体内，将调用Thread.yield（），以允许其他排队的线程运行。在要求极高性能且事件处理线数小于 CPU 逻辑核心数的场景中，推荐使用此策略；例如，CPU开启超线程的特性。

**④ BusySpinWaitStrategy**

性能最好，适合用于低延迟的系统。在要求极高性能且事件处理线程数小于CPU逻辑核心数的场景中，推荐使用此策略；例如，CPU开启超线程的特性。

**⑤ PhasedBackoffWaitStrategy**

自旋 + yield + 自定义策略，CPU资源紧缺，吞吐量和延迟并不重要的场景。

#### 3.4 单个生产者写数据的情况 ####

流程：

1.  申请写入m个元素
2.  若是有m个元素可以入，则返回最大的序列号。这儿主要判断是否会覆盖未读的元素
3.  若是返回的正确，则生产者开始写入元素

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 2]

#### 3.5 多个生产者的情况 ####

多个生产者的情况下，主要的问题是 — “如何防止多个线程重复写同一个元素”的问题。

Disruptor的解决方法是，每个线程获取不同的一段数组空间进行操作。这个通过CAS很容易达到。只需要在分配元素的时候，通过CAS判断一下这段空间是否已经分配出去即可。

但是会遇到一个新问题：如何防止读取的时候，读到还未写的元素。Disruptor在多个生产者的情况下，引入了一个与Ring Buffer大小相同的buffer：available Buffer。当某个位置写入成功的时候，便把availble Buffer相应的位置置位，标记为写入成功。读取的时候，会遍历available Buffer，来判断元素是否已经就绪。

##### 3.5.1 读数据 #####

流程：

1.  申请读取到序号n
2.  若writer cursor >= n，这时仍然无法确定连续可读的最大下标。从reader cursor开始读取available Buffer，一直查到第一个不可用的元素，然后返回最大连续可读元素的位置
3.  消费者读取元素  
    如下图所示，读线程读到下标为2的元素，三个线程Writer1/Writer2/Writer3正在向RingBuffer相应位置写数据，写线程被分配到的最大元素下标是11。

读线程申请读取到下标从3到11的元素，判断writer cursor>=11。然后开始读取availableBuffer，从3开始，往后读取，发现下标为7的元素没有生产成功，于是WaitFor(11)返回6。然后，消费者读取下标从3到6共计4个元素。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 3]

##### 3.5.2 写数据 #####

流程：

1.  申请写入m个元素
2.  若是有m个元素可以写入，则返回最大的序列号。每个生产者会被分配一段独享的空间
3.  生产者写入元素，写入元素的同时设置available Buffer里面相应的位置，以标记自己哪些位置是已经写入成功的

如下图所示，Writer1和Writer2两个线程写入数组，都申请可写的数组空间。Writer1被分配了下标3到下表5的空间，Writer2被分配了下标6到下标9的空间

Writer1写入下标3位置的元素，同时把available Buffer相应位置置位，标记已经写入成功，往后移一位，开始写下标4位置的元素。Writer2同样的方式。最终都写入完成。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 4]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70]: /images/20221005/32157a75c1b14d539c2b7c957f384cc9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 1]: /images/20221005/3127d45e9c174e8e82634fd238d30dc2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 2]: /images/20221005/0da182c0e4ac4546a4a53a8abebf397b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 3]: /images/20221005/8c46fc3c1d154a19a1d2bcfb318ac573.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZWd1Y2hlbg_size_16_color_FFFFFF_t_70 4]: /images/20221005/298fd094ce914dd2835e608ffbe2654a.png