深度详解高性能队列：Disruptor

前言

并发框架Disruptor是一个高性能队列，其凭借无锁，消除伪共享等策略极大提升了队列性能，本篇文章将基于示例和源码，对Disruptor高性能队列的使用和原理进行学习。

Disruptor版本：3.4.0

正文

一. Disruptor结构分析和组件介绍

Disruptor中的核心组件是RingBuffer，基于RingBuffer的生产者消费者模型，如下所示。

RingBuffer中有一个entries字段，是一个Object数组结构，RingBuffer使用entries来存储元素，队列工作过程就是生产者将数据写入到RingBuffer的元素中，消费者从RingBuffer获取元素中的数据。下面给出一种最简单的使用场景，即单生产者场景。

Disruptor没有对队列中的元素类型做定义，需要使用者自行定义元素类型，本示例中将队列的元素定义为TestEvent，如下所示。

public class TestEvent {

    private String id;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

}
复制代码

然后定义TestEventHandler实现EventHandler接口，每个TestEventHandler都需要注册到Disruptor中，Disruptor会基于每个注册的TestEventHandler来创建BatchEventProcessor作为消费者，每个BatchEventProcessor消费到元素后会将元素交给其持有的TestEventHandler来处理。TestEventHandler实现如下所示。

public class TestEventHandler implements EventHandler<TestEvent> {

    private final String consumerId;

    public TestEventHandler(String consumerId) {
        this.consumerId = consumerId;
    }

    @Override
    public void onEvent(TestEvent testEvent, long sequence, boolean endOfBatch) {
        System.out.println("Consumer-EventHandler-" + this.consumerId + " consumed message: " + testEvent.getId());
    }

}
复制代码

再然后定义TestEventFactory实现EventFactory接口，用于帮助Disruptor在初始化RingBuffer时一次性将元素全部创建出来并填充满元素数组。TestEventFactory实现如下所示。

public class TestEventFactory implements EventFactory<TestEvent> {

    @Override
    public TestEvent newInstance() {
        return new TestEvent();
    }

}
复制代码

最后是生产者，同样的，Disruptor没有对生产者做定义，本示例中自行封装的生产者如下所示。

public class TestEventProducer {

    private final RingBuffer<TestEvent> ringBuffer;

    public TestEventProducer(RingBuffer<TestEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    public void onData(String data) {
        long sequence = ringBuffer.next();
        try {
            TestEvent testEvent = ringBuffer.get(sequence);
            testEvent.setId(data);
        } finally {
            ringBuffer.publish(sequence);
        }
    }

}
复制代码

下面是一个测试程序，结合上述定义好的类，对生产和消费的简单工作流程进行演示。

public class MyTest {

    private static final String CONSUMER_ID_1 = "1";
    private static final String CONSUMER_ID_2 = "2";
    private static final String CONSUMER_ID_3 = "3";

    private static final int RING_BUFFER_SIZE = 1024 * 1024;
    private static final int WAIT_MS = 1000;
    private static final int BATCH_NUM = 3;

    public static void main(String[] args) throws Exception {
        TestEventFactory factory = new TestEventFactory();
        // 创建Disruptor，指定生产者类型为单生产者
        Disruptor<TestEvent> disruptor = new Disruptor<>(factory, RING_BUFFER_SIZE,
                Executors.defaultThreadFactory(), ProducerType.SINGLE, new YieldingWaitStrategy());
        // 向Disruptor注册TestEventHandler，即注册消费者
        disruptor.handleEventsWith(new TestEventHandler(CONSUMER_ID_1),
                new TestEventHandler(CONSUMER_ID_2), new TestEventHandler(CONSUMER_ID_3));
        // 开启Disruptor，基于线程池将消费者运行起来
        disruptor.start();
        Thread.sleep(WAIT_MS);
        // 创建生产者，并将数据写入RingBuffer的元素中
        RingBuffer<TestEvent> ringBuffer = disruptor.getRingBuffer();
        TestEventProducer testEventProducer = new TestEventProducer(ringBuffer);
        for (int i = 0; i < BATCH_NUM; i++) {
            testEventProducer.onData(String.valueOf(i));
        }
        Thread.sleep(WAIT_MS);
        // 关闭Disruptor
        disruptor.shutdown();
    }

}
复制代码

结合上述示例，在Disruptor框架中有如下几个关键角色。

• Disruptor对象。可以理解为Disruptor框架中的锚点，其持有一个RingBuffer对象，一个线程池Executor对象以及一个ConsumerRepository对象，生产者生产的数据会存放在RingBuffer中的元素中，同时当向Disruptor注册事件处理器时Disruptor会基于注册的事件处理器创建消费者并添加到ConsumerRepository中；
• RingBuffer对象。Disruptor框架中的核心对象，其持有一个Object数组用于存放元素以及一个Sequencer对象实现对生产者的同步控制；
• Sequencer对象。其实际是一个接口，有两个实现类分别为SingleProducerSequencer和MultiProducerSequencer，代表对单生产者和多生产者的同步控制（可以这么理解，上面示例中定义的生产者TestEventProducer如果向RingBuffer生产元素，那么就会和其他生产者以及消费者产生并发冲突，Sequencer就是用于控制并解决这个并发冲突的）；
• SequenceBarrier对象。其由Sequencer创建，并且会由消费者持有，主要用于消费者获取当前可以消费的元素的序号；
• EventProcessor对象。其实际是一个接口，表示消费者，当向Disruptor对象注册EventHandler对象时，Disruptor会基于EventHandler创建一个BatchEventProcessor对象作为消费者，当向Disruptor注册WorkHandler对象时，Disruptor会基于WorkHandler创建一个WorkProcessor对象作为消费者，本篇文章提及的消费者全部指BatchEventProcessor；
• Sequence对象。每个EventProcessor消费者会持有一个Sequence，同时SingleProducerSequencer持有一个Sequence，MultiProducerSequencer持有两个Sequence