Disruptor—1.原理和使用简介

大纲

1.Disruptor简介

2.Disruptor和BlockingQueue的压测对比

3.Disruptor的编程模型

4.Disruptor的数据结构与生产消费模型

5.RingBuffer + Disruptor + Sequence相关类

6.Disruptor的WaitStrategy消费者等待策略

7.EventProcessor + EventHandler等类

8.Disruptor的运行原理图

9.复杂业务需求下的编码方案和框架

10.Disruptor的串行操作

11.Disruptor的并行操作

12.Disruptor的多边形操作

13.Disruptor的多生产者和多消费者

1.Disruptor简介

(1)Disruptor是什么

(2)Disruptor的特点

(3)Disruptor的核心

(1)Disruptor是什么

Martin Fowler在自己网站上写了一篇LMAX架构的文章，在文章中他介绍了LMAX是一种新型零售金融交易平台，能够以很低的延迟产生大量的交易。LMAX是建立在JVM平台上，其核心是一个业务逻辑处理器，能够在一个线程里每秒处理6百万订单。LMAX业务逻辑处理器完全是运行在内存中，使用事件驱动方式，其核心是Disruptor。

(2)Disruptor的特点

大大简化了并发程序开发的难度，性能上比Java提供的一些并发包还好。

Disruptor是一个高性能异步处理框架，实现了观察者模式。Disruptor是无锁的、是CPU友好的。Disruptor不会清除缓存中的数据，只会覆盖缓存中的数据，不需要进行垃圾回收。Disruptor业务逻辑是纯内存操作，使用事件驱动方式。

(3)Disruptor的核心

Disruptor核心是一个RingBuffer，RingBuffer是一个数组，没有首尾指针。RingBuffer是一个首尾相接的环，用于在不同线程之间传递数据。

如果RingBuffer满了，是继续覆盖还是等待消费，由生产者和消费者决定。假设RingBuffer满了，生产者有两个选择：选择一是等待RingBuffer有空位再填充，选择二是直接覆盖。同时消费者也有两种选择：选择一是等待RingBuffer满了再消费，选择二是RingBuffer填充一个就消费一个。

RingBuffer有一个序号Sequence，这个序号指向数组中下一个可用元素。随着数据不断地填充这个数组，这个序号会一直增长，直到绕过这个环。序号指向的元素，可以通过mod计算：序号 % 长度 = 索引。建议将长度设为2的n次方，有利于二进制计算：序号 & (长度 - 1) = 索引。

Sequence通过顺序递增的序号来进行编号，以此管理正在进行交换的数据(事件)。对数据处理的过程总是沿着需要逐个递增处理，从而实现线程安全。一个Sequence用于跟踪标识某个特定的事件处理者的处理进度。

2.Disruptor和BlockingQueue的压测对比

Disruptor的性能是ArrayBlockingQueue的3倍+，这里的测试代码都是基于单线程的单生产者单消费者模式运行的。但是Disruptor本身就支持多生产者多消费者模型，测试中使用单线程明显降低了其性能。而ArrayBlockingQueue在多生产者多消费者场景下，其性能又会比单生产者单消费者场景下更低。因此，在实际应用中，Disruptor的性能会是ArrayBlockingQueue的3倍+。

public interface Constants {
    int EVENT_NUM_OHM = 100000000;
    int EVENT_NUM_FM = 50000000;
    int EVENT_NUM_OM = 10000000;
}

public class ArrayBlockingQueue4Test {
    public static void main(String[] args) {
        //初始化一个大小为100000000的有界队列ArrayBlockingQueue，为了避免在测试时由于扩容影响性能，所以一开始就初始化大小为1亿
        final ArrayBlockingQueue<Data> queue = new ArrayBlockingQueue<Data>(100000000);
        //开始时间
        final long startTime = System.currentTimeMillis();
        //向容器中添加元素
        new Thread(new Runnable() {
            public void run() {
                long i = 0;
                //首先把数据投递到有界队列ArrayBlockingQueue，单线程的生产者
                while (i < Constants.EVENT_NUM_OHM) {
                    Data data = new Data(i, "c" + i);
                    try {
                        queue.put(data);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    i++;
                }
            }
        }).start();

        //从容器中取出元素
        new Thread(new Runnable() {
            public void run() {
                int k = 0;
                //然后才开始消费有界队列中的数据，单线程的消费者
                while (k < Constants.EVENT_NUM_OHM) {
                    try {
                        queue.take();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    k++;
                }
                //结束时间
                long endTime = System.currentTimeMillis();
                //整个main函数就是单线程运行，处理1千万数据，大概耗时3.6秒
                System.out.println("ArrayBlockingQueue costTime = " + (endTime - startTime) + "ms");
            }
        }).start();
    }
}

public class DisruptorSingle4Test {
    public static void main(String[] args) {
        int ringBufferSize = 65536;
        final Disruptor<Data> disruptor = new Disruptor<Data>(
            new EventFactory<Data>() {
                public Data newInstance() {
                    return new Data();
                }
            },
            ringBufferSize,
            //设置为单线程运行
            Executors.newSingleThreadExecutor(),
            //单生产者模式
            ProducerType.SINGLE,
            //new BlockingWaitStrategy()
            new YieldingWaitStrategy()
        );

        //创建一个消费者事件处理器
        DataConsumer consumer = new DataConsumer();
        //消费数据
        disruptor.handleEventsWith(consumer);
        disruptor.start();

        //单线程的消费者
        new Thread(new Runnable() {
            public void run() {
                RingBuffer<Data> ringBuffer = disruptor.getRingBuffer();
                for (long i = 0; i < Constants.EVENT_NUM_OHM; i++) {
                    long seq = ringBuffer.next();
                    Data data = ringBuffer.get(seq);
                    data.setId(i);
                    data.setName("c" + i);
                    //发布一个数据被消费的事件
                    ringBuffer.publish(seq);
                }
            }
        }).start();
    }
}

public class DataConsumer implements EventHandler<Data> {
    private long startTime;
    private int i;

    public DataConsumer() {
        this.startTime = System.currentTimeMillis();
    }

    public void onEvent(Data data, long seq, boolean bool) throws Exception {
        i++;
        if (i == Constants.EVENT_NUM_OHM) {
            long endTime = System.currentTimeMillis();
            //处理1千万的数据，大概耗时1.1秒
            System.out.println("Disruptor costTime = " + (endTime - startTime) + "ms");
            //可见Disruptor的性能是ArrayBlockingQueue的3倍+
        }
    }
}

3.Disruptor的编程模型

(1)Disruptor的使用步骤

(2)Disruptor的使用演示

(1)Disruptor的使用步骤

步骤一：建立一个Event工厂类，用于创建数据(Event类实例对象)
步骤二：建立一个监听事件类(Event处理器)，用于处理数据(Event类实例对象)
步骤三：创建Disruptor实例，配置一系列参数
步骤四：编写生产者组件，向Disruptor容器投递数据

(2)Disruptor的使用演示

一.引入pom依赖

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

二.建立Event工厂类用于创建数据

Event工厂类创建的数据就是Event类实例对象。

public class OrderEvent {
    //订单的价格
    private long value;

    public long getValue() {
        return value;
    }

    public void setValue(long value) {
        this.value = value;
    }
}

public class OrderEventFactory implements EventFactory<OrderEvent> {
    //返回一个空的数据对象(OrderEvent对象实例)
    public OrderEvent newInstance() {
        return new OrderEvent();
    }
}

三.建立监听事件类用于处理数据

监听事件类就是Event处理器，处理的数据就是Event类实例对象。

public class OrderEventHandler implements EventHandler<OrderEvent> {
    public void onEvent(OrderEvent event, long sequence, boolean endOfBatch) throws Exception {
        Thread.sleep(1000);
        System.err.println("消费者: " + event.getValue());
    }
}

四.创建Disruptor对象实例

public class Main {
    public static void main(String[] args) {
        //参数准备
        OrderEventFactory orderEventFactory = new OrderEventFactory();
        int ringBufferSize = 4;
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        //参数一：eventFactory，消息(Event)工厂对象
        //参数二：ringBufferSize，容器的长度
        //参数三：executor，线程池(建议使用自定义线程池)，RejectedExecutionHandler
        //参数四：ProducerType，单生产者还是多生产者
        //参数五：waitStrategy，等待策略
        //1.实例化Disruptor对象
        Disruptor<OrderEvent> disruptor = new Disruptor<OrderEvent>(
            orderEventFactory,
            ringBufferSize,
            executor,
            ProducerType.SINGLE,//单生产者
            new BlockingWaitStrategy()
        );

        //2.添加Event处理器，用于处理事件
        //也就是构建Disruptor与消费者的一个关联关系
        disruptor.handleEventsWith(new OrderEventHandler());

        //3.启动disruptor
        disruptor.start();
        ...
    }
}

五.编写生产者组件向Disruptor容器投递数据

public class Main {
    public static void main(String[] args) {
        //参数准备
        OrderEventFactory orderEventFactory = new OrderEventFactory();
        int ringBufferSize = 4;
        ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

        //参数一：eventFactory，消息(Event)工厂对象
        //参数二：ringBufferSize，容器的长度
        //参数三：executor，线程池(建议使用自定义线程池)，RejectedExecutionHandler
        //参数四：ProducerType，单生产者还是多生产者
        //参数五：waitStrategy，等待策略
        //1.实例化Disruptor对象
        Disruptor<OrderEvent> disruptor = new Disruptor<OrderEvent>(
            orderEventFactory,
            ringBufferSize,
            executor,
            ProducerType.SINGLE,
            new BlockingWaitStrategy()
        );

        //2.添加Event处理器，用于处理事件
        //也就是构建Disruptor与消费者的一个关联关系
        disruptor.handleEventsWith(new OrderEventHandler());

        //3.启动disruptor
        disruptor.start();

        //4.获取实际存储数据的容器: RingBuffer
        RingBuffer<OrderEvent> ringBuffer = disruptor.getRingBuffer();
        OrderEventProducer producer = new OrderEventProducer(ringBuffer);
        ByteBuffer bb = ByteBuffer.allocate(8);
        for (long i = 0; i < 5; i++) {
            bb.putLong(0, i);
            //向容器中投递数据
            producer.sendData(bb);
        }

        disruptor.shutdown();
        executor.shutdown();
    }
}

public class OrderEventProducer {
    private RingBuffer<OrderEvent> ringBuffer;

    public OrderEventProducer(RingBuffer<OrderEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    public void sendData(ByteBuffer data) {
        //1.在生产者发送消息时, 首先需要从ringBuffer里获取一个可用的序号
        long sequence = ringBuffer.next();
        try {
            //2.根据这个序号, 找到具体的"OrderEvent"元素
            //注意：此时获取的OrderEvent对象是一个没有被赋值的"空对象"
            OrderEvent event = ringBuffer.get(sequence);
            //3.进行实际的赋值处理
            event.setValue(data.getLong(0));
        } finally {
            //4.提交发布操作
            ringBuffer.publish(sequence);
        }
    }
}

4.Disruptor的数据结构与生产消费模型

(1)Disruptor的核心与原理

(2)Disruptor的RingBuffer数据结构

(3)Disruptor的生产消费模型

(1)Disruptor的核心与原理

Disruptor的核心是RingBuffer，生产者向RingBuffer中写入元素，消费者从RingBuffer中消费元素。

(2)Disruptor的RingBuffer数据结构

RingBuffer是一个首尾相接的环(数组)，用于在不同上下文(线程)之间传递数据。

RingBuffer拥有一个序号，这个序号指向数组中下一个可用的元素。随着生产者不停地往RingBuffer写入元素，这个序号也会一直增长，直到这个序号绕过这个环。

要找到RingBuffer数组中当前序号指向的元素，可以通过mod操作：序号 % 数组长度 = 数组索引。建议将长度设为2的n次方，有利于二进制计算：序号 & (长度 - 1) = 索引。

(3)Disruptor的生产消费模型

一.消费快生产慢

如果消费者从RingBuffer消费元素的速度大于生产者写入元素的速度，那么当消费者发现RingBuffer没有元素时，就要停下等待生产者写入元素。

二.生产快消费慢

如果生产者向RingBuffer写入元素的速度大于消费者消费元素的速度，那么当生产者发现RingBuffer已经满了，就要停下等待消费者消费元素。

因为RingBuffer数组的长度是有限的，生产者写入到RingBuffer的末尾时，会从RingBuffer的开始位置继续写入，这时候生产者就可能会追上消费者。

5.RingBuffer + Disruptor + Sequence相关类

(1)RingBuffer类

(2)Disruptor类

(3)Sequence类

(4)Sequencer接口

(5)SequenceBarrier类

(1)RingBuffer类

RingBuffer不仅是基于数组的缓存，也是创建Sequencer与定义WaitStrategy的入口。

(2)Disruptor类

Disruptor类可认为是一个持有RingBuffer、消费者线程池、消费者集合等引用的辅助类。

(3)Sequence类

通过顺序递增的序号来编号，管理正在进行交换的数据(事件)。对数据(事件)的处理总是沿着序号逐个递增，所以能够实现多线程下的并发安全与原子性。

一个Sequence用于跟踪标识某个特定的事件处理者的处理进度，也就是事件处理者在RingBuffer中的处理进度。每一个Producer和Consumer都有一个自己的Sequence。

Sequence可以看成是一个AtomicLong类型字段，用于标识进度。Sequence还可以防止不同Sequence之间CPU缓存的伪共享问题。

Sequence的两个作用：

作用一：用于递增标识进度

作用二：用于消除伪共享

(4)Sequencer接口

一.Sequencer包含Sequence

二.Sequencer接口有两个实现类

第一个实现类是SingleProducerSequencer

第二个实现类是MultiProducerSequencer

(5)SequenceBarrier类

作用一：用于保持对RingBuffer的生产者和消费者之间的平衡关系，比如让生产者或消费者进行等待、唤醒生产者或消费者

作用二：决定消费者是否还有可处理的事件

6.Disruptor的WaitStrategy消费者等待策略

(1)WaitStrategy接口的作用

(2)消费者等待策略的种类

(3)BlockingWaitStrategy

(4)SleepingWaitStrategy

(5)YieldingWaitStrategy

(1)WaitStrategy接口的作用

决定一个消费者将会如何等待生产者将Event投递到Disruptor。

(2)消费者等待策略的种类

BlockingWaitStrategy，通过阻塞的方式进行等待
SleepingWaitStrategy，通过休眠的方式进行等待
YieldingWaitStrategy，通过线程间的切换的方式进行等待

(3)BlockingWaitStrategy

BlockingWaitStrategy是最低效的等待策略，但是对CPU的消耗最小，并且在各种不同部署环境中能提供一致的性能表现。该策略需要使用到Java中的锁，也就是会通过ReentrantLock来阻塞消费者线程。而Disruptor本身是一个无锁并发框架，所以如果追求高性能，就不要选择这种策略。

(4)SleepingWaitStrategy

SleepingWaitStrategy是性能一般的等待策略，其性能表现和BlockingWaitStrategy差不多。但由于SleepingWaitStrategy是无锁的，所以对生产者线程的影响最小。该策略对CPU的消耗一般，通过在单个线程循环 + yield切换线程实现，所以这种策略特别适合于异步日志类似的场景。

(5)YieldingWaitStrategy

YieldingWaitStrategy的性能是最好的，适合于低延迟的系统。不过该策略对CPU的消耗最高，因为完全基于yield切换线程来实现。推荐用于要求高性能且事件处理线程数小于CPU逻辑核心数的场景中，尤其是当CPU开启了超线程特性的时候。

7.EventProcessor + EventHandler等类

(1)Event对象

(2)EventProcessor接口

(3)EventHandler接口

(4)WorkProcessor类

(1)Event对象

Disruptor中的Event指的是从生产者到消费者过程中所处理的数据对象。Disruptor中没有代码表示Event，它用泛型表示，完全由用户定义。比如创建一个RingBuffer对象时，其中的泛型就表示着这个Event对象。

(2)EventProcessor接口

EventProcessor用于处理Disruptor中的Event，拥有消费者的Sequence，它有一个实现类叫BatchEventProcessor。

由于EventProcessor接口继承自Runnable接口，所以BatchEventProcessor类会实现Runnable接口的run()方法。

其实BatchEventProcessor类是Disruptor框架中最核心的类，因为它的run()方法会不断轮询并获取数据对象，然后把数据对象(Event)交给消费者去处理，也就是即回调EventHandler接口的实现类对象的onEvent()方法。

(3)EventHandler接口

EventHandler是由用户实现的并且代表了Disruptor中的一个消费者接口，也就是消费者逻辑需要在EventHandler接口的onEvent()方法实现。

(4)WorkProcessor类

WorkProcessor类可确保每个Sequence只被一个Processor消费。注意：在单消费者模式下，使用的是EventHandler，对应于EventProcessor。在多消费者模式下，使用的是WorkHandler，对应于WorkProcessor。

8.Disruptor的运行原理图

9.复杂业务需求下的编码方案和框架

(1)方案选择

(2)框架选择

(1)方案选择

方案一：完全解耦的模式，比如一个子业务线也开一个项目，此时重复代码会比较多。

方案二：模版方法模式，如果业务快速迭代，可能也会需要经常重构底层的模版方法。

(2)框架选择

一.使用有限状态机框架

二.使用Disruptor框架

10.Disruptor的串行操作

Disruptor的串行操作，可以通过链式调用handleEventsWith()方法来实现。

如果使用RingBuffer对象来发布事件，那么需要先从RingBuffer对象中获取一个可用的序号，然后根据序号获取Event对象并对Event对象赋值，最后调用RingBuffer的publish()方法发布事件。

如果使用Disruptor对象来发布事件，那么直接调用Disruptor的publishEvent()方法发布事件即可。

此外，实际应用中不建议通过Executors来创建线程池，而应通过ThreadPoolExecutor构造函数具体指定线程池的每一个参数。因为Executors创建的线程池还是可能有安全隐患，比如Executors的newFixedThreadPool()方法使用的是无界队列，其使用的LinkedBlockingQueue是一个可选是否有界的阻塞队列。

//Disruptor中的Event
public class Trade {
    private String id;
    private String name;
    private double price;
    private AtomicInteger count = new AtomicInteger(0);

    public Trade() {

    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public AtomicInteger getCount() {
        return count;
    }

    public void setCount(AtomicInteger count) {
        this.count = count;
    }
}

public class Main {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {
        //实际应用中不建议这样创建线程池，而应通过ThreadPoolExecutor构造函数具体指定每个参数
        //因为这种创建的线程池还是有安全隐患，比如newFixedThreadPool()使用的是无界队列
        //LinkedBlockingQueue是一个可选是否有界的阻塞队列
        ExecutorService es1 = Executors.newFixedThreadPool(8);
        //构建一个线程池用于提交任务
        ExecutorService es2 = Executors.newFixedThreadPool(1);

        //1.构建Disruptor
        Disruptor<Trade> disruptor = new Disruptor<Trade>(
            new EventFactory<Trade>() {
                public Trade newInstance() {
                    return new Trade();
                }
            },
            1024 * 1024,
            es1,
            ProducerType.SINGLE,
            new BusySpinWaitStrategy()
        );

        //2.把消费者设置到Disruptor中，也就是使用Disruptor.handleEventsWith()方法
        //串行操作，通过链式编程实现
        disruptor.handleEventsWith(new Handler1())
            .handleEventsWith(new Handler2())
            .handleEventsWith(new Handler3());

        //3.启动disruptor并获取RingBuffer
        RingBuffer<Trade> ringBuffer = disruptor.start();

        CountDownLatch latch = new CountDownLatch(1);
        long begin = System.currentTimeMillis();
        //通过线程池向Disruptor发布事件(生产数据)
        es2.submit(new TradePublisher(latch, disruptor));
        latch.await();

        disruptor.shutdown();
        es1.shutdown();
        es2.shutdown();
        System.err.println("总耗时: " + (System.currentTimeMillis() - begin));
    }
}

public class TradePublisher implements Runnable {
    private static int PUBLISH_COUNT = 10;
    private Disruptor<Trade> disruptor;
    private CountDownLatch latch;

    public TradePublisher(CountDownLatch latch, Disruptor<Trade> disruptor) {
        this.disruptor = disruptor;
        this.latch = latch;
    }

    public void run() {
        TradeEventTranslator eventTranslator = new TradeEventTranslator();
        for (int i = 0; i < PUBLISH_COUNT; i++) {
            //新的发布事件的方式，另一种方式就是通过传入的RingBuffer的publish()方法发布事件
            disruptor.publishEvent(eventTranslator);
        }
        latch.countDown();
    }
}

class TradeEventTranslator implements EventTranslator<Trade> {
    private Random random = new Random();

    public void translateTo(Trade event, long sequence) {
        this.generateTrade(event);
    }

    private void generateTrade(Trade event) {
        event.setPrice(random.nextDouble() * 9999);
    }
}

public class Handler1 implements EventHandler<Trade>, WorkHandler<Trade> {
    //实现EventHandler的onEvent()方法，可以监听生产者发布的事件
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        this.onEvent(event);
    }

    //实现WorkHandler的onEvent()方法，也可以监听生产者发布的事件
    public void onEvent(Trade event) throws Exception {
        System.err.println("handler 1 : SET NAME");
        Thread.sleep(1000);
        event.setName("H1");
    }
}

public class Handler2 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 2 : SET ID");
        Thread.sleep(2000);
        event.setId(UUID.randomUUID().toString());
    }
}

public class Handler3 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 3 : NAME: " + event.getName() + ", ID: " + event.getId() + ", PRICE: " + event.getPrice() + " INSTANCE : " + event.toString());
    }
}

11.Disruptor的并行操作

Disruptor的并行操作可以有两种方式实现：方式一是调用handleEventsWith()方法时传入多个handler对象，方式二是分别多次调用handleEventsWith()方法。

public class Main {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {
        //实际应用中不建议这样创建线程池，而应通过ThreadPoolExecutor构造函数具体指定每个参数
        //因为这种创建的线程池还是有安全隐患，比如newFixedThreadPool()使用的是无界队列
        //LinkedBlockingQueue是一个可选是否有界的阻塞队列
        ExecutorService es1 = Executors.newFixedThreadPool(8);
        //构建一个线程池用于提交任务
        ExecutorService es2 = Executors.newFixedThreadPool(1);

        //1.构建Disruptor
        Disruptor<Trade> disruptor = new Disruptor<Trade>(
            new EventFactory<Trade>() {
                public Trade newInstance() {
                    return new Trade();
                }
            },
            1024 * 1024,
            es1,
            ProducerType.SINGLE,
            new BusySpinWaitStrategy()
        );

        //2.把消费者设置到Disruptor中，也就是使用Disruptor.handleEventsWith()方法
        //Disruptor的并行操作可以有两种方式实现
        //方式一：调用handleEventsWith方法时传入多个handler对象
        disruptor.handleEventsWith(new Handler1(), new Handler2(), new Handler3());

        //方式二：分别多次调用handleEventsWith()方法
        //disruptor.handleEventsWith(new Handler1());
        //disruptor.handleEventsWith(new Handler2());
        //disruptor.handleEventsWith(new Handler3());

        //3.启动disruptor并获取RingBuffer
        RingBuffer<Trade> ringBuffer = disruptor.start();

        CountDownLatch latch = new CountDownLatch(1);
        long begin = System.currentTimeMillis();
        //通过线程池向Disruptor发布事件(生产数据)
        es2.submit(new TradePublisher(latch, disruptor));
        latch.await();

        disruptor.shutdown();
        es1.shutdown();
        es2.shutdown();
        System.err.println("总耗时: " + (System.currentTimeMillis() - begin));
    }
}

public class TradePublisher implements Runnable {
    private static int PUBLISH_COUNT = 10;
    private Disruptor<Trade> disruptor;
    private CountDownLatch latch;

    public TradePublisher(CountDownLatch latch, Disruptor<Trade> disruptor) {
        this.disruptor = disruptor;
        this.latch = latch;
    }

    public void run() {
        TradeEventTranslator eventTranslator = new TradeEventTranslator();
        for (int i = 0; i < PUBLISH_COUNT; i++) {
            //新的发布事件的方式，另一种方式就是通过传入的RingBuffer的publish()方法发布事件
            disruptor.publishEvent(eventTranslator);
        }
        latch.countDown();
    }
}

class TradeEventTranslator implements EventTranslator<Trade> {
    private Random random = new Random();

    public void translateTo(Trade event, long sequence) {
        this.generateTrade(event);
    }

    private void generateTrade(Trade event) {
        event.setPrice(random.nextDouble() * 9999);
    }
}

public class Handler1 implements EventHandler<Trade>, WorkHandler<Trade> {
    //实现EventHandler的onEvent()方法，可以监听生产者发布的事件
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        this.onEvent(event);
    }

    //实现WorkHandler的onEvent()方法，也可以监听生产者发布的事件
    public void onEvent(Trade event) throws Exception {
        System.err.println("handler 1 : SET NAME");
        Thread.sleep(1000);
        event.setName("H1");
    }
}

public class Handler2 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 2 : SET ID");
        Thread.sleep(2000);
        event.setId(UUID.randomUUID().toString());
    }
}

public class Handler3 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 3 : NAME: " + event.getName() + ", ID: " + event.getId() + ", PRICE: " + event.getPrice() + " INSTANCE : " + event.toString());
    }
}

12.Disruptor的多边形操作

(1)Disruptor的菱形操作

(2)Disruptor的六边形操作

Disruptor可以实现串并行同时编码。

(1)Disruptor的菱形操作

可以理解为先并行执行，然后再串行执行，类似于CyclicBarrier。

菱形操作方式一：调用handleEventsWith()方法时传入多个参数 + 链式调用。

菱形操作方式二：调用handleEventsWith()方法时传入多个参数 + 使用then()方法。

public class Main {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {
        //实际应用中不建议这样创建线程池，而应通过ThreadPoolExecutor构造函数具体指定每个参数
        //因为这种创建的线程池还是有安全隐患，比如newFixedThreadPool()使用的是无界队列
        //LinkedBlockingQueue是一个可选是否有界的阻塞队列
        ExecutorService es1 = Executors.newFixedThreadPool(8);
        //构建一个线程池用于提交任务
        ExecutorService es2 = Executors.newFixedThreadPool(1);

        //1.构建Disruptor
        Disruptor<Trade> disruptor = new Disruptor<Trade>(
            new EventFactory<Trade>() {
                public Trade newInstance() {
                    return new Trade();
                }
            },
            1024 * 1024,
            es1,
            ProducerType.SINGLE,
            new BusySpinWaitStrategy()
        );

        //2.把消费者设置到Disruptor中，也就是使用Disruptor.handleEventsWith()方法
        //菱形操作一
        disruptor.handleEventsWith(new Handler1(), new Handler2())
           .handleEventsWith(new Handler3());

        //菱形操作二
        //EventHandlerGroup<Trade> ehGroup = disruptor.handleEventsWith(new Handler1(), new Handler2());
        //ehGroup.then(new Handler3());

        //3.启动disruptor并获取RingBuffer
        RingBuffer<Trade> ringBuffer = disruptor.start();

        CountDownLatch latch = new CountDownLatch(1);
        long begin = System.currentTimeMillis();
        //通过线程池向Disruptor发布事件(生产数据)
        es2.submit(new TradePublisher(latch, disruptor));
        latch.await();

        disruptor.shutdown();
        es1.shutdown();
        es2.shutdown();
        System.err.println("总耗时: " + (System.currentTimeMillis() - begin));
    }
}

public class TradePublisher implements Runnable {
    private static int PUBLISH_COUNT = 10;
    private Disruptor<Trade> disruptor;
    private CountDownLatch latch;

    public TradePublisher(CountDownLatch latch, Disruptor<Trade> disruptor) {
        this.disruptor = disruptor;
        this.latch = latch;
    }

    public void run() {
        TradeEventTranslator eventTranslator = new TradeEventTranslator();
        for (int i = 0; i < PUBLISH_COUNT; i++) {
            //新的发布事件的方式，另一种方式就是通过传入的RingBuffer的publish()方法发布事件
            disruptor.publishEvent(eventTranslator);
        }
        latch.countDown();
    }
}

class TradeEventTranslator implements EventTranslator<Trade> {
    private Random random = new Random();

    public void translateTo(Trade event, long sequence) {
        this.generateTrade(event);
    }

    private void generateTrade(Trade event) {
        event.setPrice(random.nextDouble() * 9999);
    }
}

public class Handler1 implements EventHandler<Trade>, WorkHandler<Trade> {
    //实现EventHandler的onEvent()方法，可以监听生产者发布的事件
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        this.onEvent(event);
    }

    //实现WorkHandler的onEvent()方法，也可以监听生产者发布的事件
    public void onEvent(Trade event) throws Exception {
        System.err.println("handler 1 : SET NAME");
        Thread.sleep(1000);
        event.setName("H1");
    }
}

public class Handler2 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 2 : SET ID");
        Thread.sleep(2000);
        event.setId(UUID.randomUUID().toString());
    }
}

public class Handler3 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 3 : NAME: " + event.getName() + ", ID: " + event.getId() + ", PRICE: " + event.getPrice() + " INSTANCE : " + event.toString());
    }
}

(2)Disruptor的六边形操作

通过Disruptor的after()方法 + 菱形操作，可实现六边形操作。

注意在单消费者模式下：一个EventHandler会对应一个BatchEventProcessor，所以如果有n个EventHandler监听Disruptor，那么初始化Disruptor时的线程池就要有n个线程，否则可能导致多边形操作失效。

在单消费者模式下，如果有非常多EventHandler，就需要非常多线程。此时是不合理的，所以如果有很多EventHandler，可采用多消费者模式。

public class Main {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) throws Exception {
        //实际应用中不建议这样创建线程池，而应通过ThreadPoolExecutor构造函数具体指定每个参数
        //因为这种创建的线程池还是有安全隐患，比如newFixedThreadPool()使用的是无界队列
        //LinkedBlockingQueue是一个可选是否有界的阻塞队列
        ExecutorService es1 = Executors.newFixedThreadPool(8);
        //构建一个线程池用于提交任务
        ExecutorService es2 = Executors.newFixedThreadPool(1);

        //1.构建Disruptor
        Disruptor<Trade> disruptor = new Disruptor<Trade>(
            new EventFactory<Trade>() {
                public Trade newInstance() {
                    return new Trade();
                }
            },
            1024 * 1024,
            es1,
            ProducerType.SINGLE,
            new BusySpinWaitStrategy()
        );

        //2.把消费者设置到Disruptor中，也就是使用Disruptor.handleEventsWith()方法
        //六边形操作
        Handler1 h1 = new Handler1();
        Handler2 h2 = new Handler2();
        Handler3 h3 = new Handler3();
        Handler4 h4 = new Handler4();
        Handler5 h5 = new Handler5();
        disruptor.handleEventsWith(h1, h4);
        disruptor.after(h1).handleEventsWith(h2);
        disruptor.after(h4).handleEventsWith(h5);
        disruptor.after(h2, h5).handleEventsWith(h3);

        //3.启动disruptor并获取RingBuffer
        RingBuffer<Trade> ringBuffer = disruptor.start();

        CountDownLatch latch = new CountDownLatch(1);
        long begin = System.currentTimeMillis();
        //通过线程池向Disruptor发布事件(生产数据)
        es2.submit(new TradePublisher(latch, disruptor));
        latch.await();

        disruptor.shutdown();
        es1.shutdown();
        es2.shutdown();
        System.err.println("总耗时: " + (System.currentTimeMillis() - begin));
    }
}

public class TradePublisher implements Runnable {
    private static int PUBLISH_COUNT = 10;
    private Disruptor<Trade> disruptor;
    private CountDownLatch latch;

    public TradePublisher(CountDownLatch latch, Disruptor<Trade> disruptor) {
        this.disruptor = disruptor;
        this.latch = latch;
    }

    public void run() {
        TradeEventTranslator eventTranslator = new TradeEventTranslator();
        for (int i = 0; i < PUBLISH_COUNT; i++) {
            //新的发布事件的方式，另一种方式就是通过传入的RingBuffer的publish()方法发布事件
            disruptor.publishEvent(eventTranslator);
        }
        latch.countDown();
    }
}

class TradeEventTranslator implements EventTranslator<Trade> {
    private Random random = new Random();

    public void translateTo(Trade event, long sequence) {
        this.generateTrade(event);
    }

    private void generateTrade(Trade event) {
        event.setPrice(random.nextDouble() * 9999);
    }
}

public class Handler1 implements EventHandler<Trade>, WorkHandler<Trade> {
    //实现EventHandler的onEvent()方法，可以监听生产者发布的事件
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        this.onEvent(event);
    }

    //实现WorkHandler的onEvent()方法，也可以监听生产者发布的事件
    public void onEvent(Trade event) throws Exception {
        System.err.println("handler 1 : SET NAME");
        Thread.sleep(1000);
        event.setName("H1");
    }
}

public class Handler2 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 2 : SET ID");
        Thread.sleep(2000);
        event.setId(UUID.randomUUID().toString());
    }
}

public class Handler3 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 3 : NAME: " + event.getName() + ", ID: " + event.getId() + ", PRICE: " + event.getPrice() + " INSTANCE : " + event.toString());
    }
}

public class Handler4 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 4 : SET PRICE");
        Thread.sleep(1000);
        event.setPrice(17.0);
    }
}

public class Handler5 implements EventHandler<Trade> {
    public void onEvent(Trade event, long sequence, boolean endOfBatch) throws Exception {
        System.err.println("handler 5 : GET PRICE: " + event.getPrice());
        Thread.sleep(1000);
        event.setPrice(event.getPrice() + 3.0);
    }
}

13.Disruptor的多生产者和多消费者

注意一：使用多消费者模式时，每个消费者都需要实现WorkHandler接口，而不是EventHandler接口。单消费者模式，使用的是EventHandler，对应于EventProcessor。多消费者模式，使用的是WorkHandler，对应于WorkProcessor。

注意二：使用多消费者模式时，需要构建消费者工作池WorkerPool。

注意三：使用多消费者模式时，每个消费者需要一个Sequence来标记当前消费的最小序号。这样生产者投递消息时才能遍历消费者的Sequence找出最小的序号，然后写到最小的序号位置进行阻塞等待。

比如下图中，在某一时刻：消费者1消费了序号0和2，但序号1还没有消费完毕。消费者2消费了序号3和4，消费者3消费了序号5。此时，在RingBuffer中，虽然序号0、2、3、4、5都可以覆盖了，但由于序号1还没被消费，所以生产者最多只能覆盖到序号0的位置。然后等待序号1被消费者1消费完毕后，才能继续往RingBuffer投递消息。

//Disruptor中的 Event
public class Order {
    private String id;
    private String name;
    private double price;

    public Order() {

    }

    public String getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        //1.创建RingBuffer
        RingBuffer<Order> ringBuffer = RingBuffer.create(
            ProducerType.MULTI,//多生产者
            new EventFactory<Order>() {
                public Order newInstance() {
                    return new Order();
                }
            },
            1024 * 1024,
            new YieldingWaitStrategy()
        );

        //2.通过ringBuffer创建一个屏障
        SequenceBarrier sequenceBarrier = ringBuffer.newBarrier();

        //3.创建消费者数组，每个消费者Consumer都需要实现WorkHandler接口
        Consumer[] consumers = new Consumer[10];
        for (int i = 0; i < consumers.length; i++) {
            consumers[i] = new Consumer("C" + i);
        }

        //4.构建多消费者工作池WorkerPool，因为多消费者模式下需要使用WorkerPool
        WorkerPool<Order> workerPool = new WorkerPool<Order>(
            ringBuffer,
            sequenceBarrier,
            new EventExceptionHandler(),
            consumers
        );

        //5.设置多个消费者的sequence序号，用于单独统计每个消费者的消费进度, 并且设置到RingBuffer中
        ringBuffer.addGatingSequences(workerPool.getWorkerSequences());

        //6.启动workerPool
        workerPool.start(Executors.newFixedThreadPool(5));

        final CountDownLatch latch = new CountDownLatch(1);
        for (int i = 0; i < 100; i++) {
            final Producer producer = new Producer(ringBuffer);
            new Thread(new Runnable() {
                public void run() {
                    try {
                        latch.await();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    for (int j = 0; j < 100; j++) {
                        producer.sendData(UUID.randomUUID().toString());
                    }
                }
            }).start();
        }

        Thread.sleep(2000);
        System.err.println("----------等待线程创建完毕，才开始生产数据----------");
        latch.countDown();
        Thread.sleep(10000);
        System.err.println("任务总数:" + consumers[2].getCount());
    }

    static class EventExceptionHandler implements ExceptionHandler<Order> {
        public void handleEventException(Throwable ex, long sequence, Order event) {

        }

        public void handleOnStartException(Throwable ex) {

        }

        public void handleOnShutdownException(Throwable ex) {

        }
    }
}

public class Consumer implements WorkHandler<Order> {
    private static AtomicInteger count = new AtomicInteger(0);
    private String consumerId;
    private Random random = new Random();

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

    public void onEvent(Order event) throws Exception {
        Thread.sleep(1 * random.nextInt(5));
        System.err.println("当前消费者: " + this.consumerId + ", 消费信息ID: " + event.getId());
        count.incrementAndGet();
    }

    public int getCount() {
        return count.get();
    }
}

public class Producer {
    private RingBuffer<Order> ringBuffer;

    public Producer(RingBuffer<Order> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    public void sendData(String uuid) {
        long sequence = ringBuffer.next();
        try {
            Order order = ringBuffer.get(sequence);
            order.setId(uuid);
        } finally {
            ringBuffer.publish(sequence);
        }
    }
}