[翻译]高并发框架 LMAX Disruptor 介绍

原文地址：Concurrency with LMAX Disruptor – An Introduction

译者序

前些天在并发编程网，看到了关于 Disruptor 的介绍。感觉此框架惊为天人，值得学习学习。在把并发编程网上面介绍逐一浏览之后发觉，缺少了对于 Disruptor 基础应用的介绍。于是就有了翻译海外基础介绍的想法。

• 首先

要为以后难以在工作中用到 Disruptor 而感到沮丧。因为据介绍来看，它号称"能够在一个线程里每秒处理6百万订单" 。我所在的平台撑不起这个量，同时也限于学历跟从业背景难以去这类大公司供职。

• 其次

追逐性能，常常来说你给老板省了多少硬件，老板是看不到的。
建议一开始还是不要设计得性能太过优秀，不然老板看不到你的价值。

• 最后

Disruptor 是一个在并发编程中避免资源竞争的容器，用于协调生产者与消费者之间的关系，同时有着领域驱动模型 CQRS框架那种基于命令的影子。
应用这个框架编写代码将会较为繁复，模块与模块之前的通信全由一个又一个Event类来协调。
相对于大多数喜欢一个方法到底的开发同学来说会比较麻烦，毕竟需要定义更多类。

1. 概览

本篇文章目的在于介绍 LMAX Disruptor，探讨它是如何帮助我们实现软件低延迟、高并发特性。
我们还将介绍 Disruptor 库的基本用法。

2. Disruptor 是什么？

Disruptor 是由 LMAX 编写的开源Java库。它是个并发编程框架，用于处理大量事务，而且低延迟(然而并不会像常规并发代码那样复杂)。
如此高效的性能优化，是通过更高效的利用底层硬件的设计实现。

2.1. 机械情怀

让我们从机械情怀的核心概念开始 - 这就是了解底层硬件如何以最屌的方式运行。

举个栗子，

到CPU的延迟	CPU时钟	耗时
主内存	很多(Multiple)	~60-80 ns
L3 缓存	~40-45 周期	~15 ns
L2 缓存	~10 周期	~3 ns
L1 缓存	~3-4 周期	~1 ns
寄存器	1 周期	~15 ns

2.2. 为什么不用队列

生产者和消费者之间常常速率不一致，队列通常总是为"空"或"满"。因此队列头(head)、队列尾(tail)和队列大小(size)有着资源竞争(write contention)。生产和消费很少达到和谐的状态。

通常采用锁来解决资源竞争(write contention)问题，但与此同时又会陷入内核级别的上下文切换。当这种情况发生时，处理器所缓存的数据可能丢失。(译者注:当线程A、B分别在CPU上不同的两个内核上运行时，线程A正要更新变量Y。不幸的是，这个变量也同时正要被线程B所更新。如果核心A获得了所有权，缓存子系统将会使核心B中对应的缓存行失效。当核心B获得了所有权然后执行更新操作，核心A就要使自己对应的缓存行失效。这会来来回回的经过L3缓存，大大影响了性能。)

为了达到更好的线程可伸缩性，就必须确保不会有两个写线程操作同一个变量(多个读线程是没有问题的，如同处理器间调用高速链接获取缓存)。队列，它败在了独立写入原则(one-writer principle)。

如果两个不同的线程写入队列中两个不同的值，那么每个内核都会使另外一个线程的缓存行失效(数据在主内存与高速缓存之间的传输是做的固定大小的块传输，称之为缓存行。译者注:伪共享和缓存行)。尽管两个线程写入两个不同的变量，也同样会引起它们间的资源竞争。这叫做伪共享，因为每次访问队列头(head)，队列尾(tail)也同样会被加载到缓存行，反之亦然。

2.3. Disruptor是如何工作的？

Disruptor 有一个基于数组的循环数据结构(环装缓冲区)。这个循环数据结构，它是个拥有下个可用元素引用的数组。预先分配了对象内存空间。生产者与消费者通过这个循环数据结构进行读写操作，并不会有锁或资源竞争。

在Disruptor 中，所有事件(events)以组播的方式被发布给所有消费者，以便下游队列通过并行的方式进行消费。因为消费者的并行消费，需要协调消费者间的依赖关系(依赖关系图)。

生产者和消费者中有个序列计数器，指示缓冲区中当前正在被它所处理的元素。所有生产者或消费者都只可以修改它自己的序列计数器，但同时可以读取其他的序列计数器。

3. 使用Disruptor 库

3.1. Maven 依赖

让我们把Disruptor 库的依赖关系添加到 pom.xml中。

<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.3.6</version>
</dependency>

最新版本的依赖关系可以在这里找到。

3.2. 定义 Event 类

让我们来定义一个携带数据的 Event:

public static class ValueEvent {
    private int value;
    public final static EventFactory EVENT_FACTORY 
      = () -> new ValueEvent();
 
    // standard getters and setters
}

这个 EventFactory 会让 Disruptor分配事件。

3.3. 消费者(Consumer)

消费者从环装缓冲区读取数据。让我们来定义个处理事件的消费者:

public class SingleEventPrintConsumer {
    ...
 
    public EventHandler<ValueEvent>[] getEventHandler() {
        EventHandler<ValueEvent> eventHandler 
          = (event, sequence, endOfBatch) 
            -> print(event.getValue(), sequence);
        return new EventHandler[] { eventHandler };
    }
  
    private void print(int id, long sequenceId) {
        logger.info("Id is " + id 
          + " sequence id that was used is " + sequenceId);
    }
}

在我们的示例中，消费者只是打印打印日志。

3.4. 构造 Disruptor

构造 Disruptor:

ThreadFactory threadFactory = DaemonThreadFactory.INSTANCE;
 
WaitStrategy waitStrategy = new BusySpinWaitStrategy();
Disruptor<ValueEvent> disruptor 
  = new Disruptor<>(
    ValueEvent.EVENT_FACTORY, 
    16, 
    threadFactory, 
    ProducerType.SINGLE, 
    waitStrategy);

在这个 Disruptor 的构造方法中，依次定义了以下参数:

• Event Factory – 负责生成用于填充环装缓冲区的事件对象；
• The size of Ring Buffer – 定义环装缓冲区的大小。它必须是2的幂，否则会在初始化时抛出异常。因为重点在于使用逻辑二进制运算符有着更好的性能；(例如:mod运算)
• Thread Factory – 事件处理线程创建工厂；
• Producer Type – 指定是否有单个或者多个生产者；
• Waiting strategy – 定义如何处理无法跟上生产者步伐的慢消费者；

连接消费者处理程序:

disruptor.handleEventsWith(getEventHandler());

Disruptor可以提供多个消费者来处理生产者生成的数据。在上面的例子中，我们只使用了一个消费者处理事件。

3.5. 启动 Disruptor

RingBuffer<ValueEvent> ringBuffer = disruptor.start();

3.6 构造和发布事件(Event)

生产者将参数按顺序放置到环形缓冲区中。(译者注:3.4所述Event Factory已经作为参数，构造Disruptor对象)生产者必须获取到到下个可用元素，以避免覆盖尚未消耗的元素。

利用 RingBuffer 发布事件:

for (int eventCount = 0; eventCount < 32; eventCount++) {
    long sequenceId = ringBuffer.next();
    ValueEvent valueEvent = ringBuffer.get(sequenceId);
    valueEvent.setValue(eventCount);
    ringBuffer.publish(sequenceId);
}

在此，生产者依次生产、发布事件。值得注意的是 Disruptor 与2阶段提交协议类似。它先获取一个新序列号(sequenceId)，再通过(sequenceId)获取事件，然后制作事件，最后发布。下次获得sequenceId + 1。

4. 总结

在本教程中，我们已经阐述了 Disruptor是什么，它是如何实现低延迟的并发处理。回顾了机械情怀的理念，以及如何利用它实现低延迟。最后展示了一个使用 Disruptor 库的例子。

示例代码可以在GitHub项目中找到。这是一个基于Maven的项目，所以它很容易导入和运行。

引用：

DDD CQRS架构和传统架构的优缺点比较
伪共享(False Sharing)
伪共享和缓存行

ps:

此次翻译拖了快两个月，纠结、消沉、迷离、回归。
开始觉得不断的技术探索，仿佛只是对于前途的过多焦虑，让自己更多的沉浸于忙碌，从而更多的抬头看路。
看到很多人接下来的路，只是混混资历跟业务。然后慢慢的加薪拿股权，就算是人工智能其实也没有什么明朗的技术变现路线。
技术再好，也需要自我营销与宣传。止步眼前，心中颇多不甘。