Disruptor相关概念，包括等待策略，多消费者之间的依赖关系

在定义Disruptor中，如下

Disruptor<LongEvent> parallelDisruptor = new Disruptor<LongEvent>(eventFactory,bufferSize, Executors.defaultThreadFactory(),ProducerType.SINGLE,new BlockingWaitStrategy());

使用的等待策略是BlockingWaitStrategy，除了这个策略，还有如下几个策略。

 

waitStrategy 等待策略

BlockingWaitStrategy默认的等待策略。利用锁和等待机制的WaitStrategyCPU消耗少但是延迟比较高

BusySpinWaitStrategy自旋等待。这种策略会利用CPU资源来避免系统调用带来的延迟抖动当线程可以绑定到指定CPU(核)的时候可以使用这个策略。

LiteBlockingWaitStrategy实现方法也是阻塞等待

SleepingWaitStrategy是另一种较为平衡CPU消耗与延迟的WaitStrategy在不同次数的重试后采用不同的策略选择继续尝试或者让出CPU或者sleep。这种策略延迟不均匀。

TimeoutBlockingWaitStrategy实现方法是阻塞给定的时间超过时间的话会抛出超时异常。

YieldingWaitStrategy实现方法是先自旋(100次)不行再临时让出调度(yield)。和SleepingWaitStrategy一样也是一种高性能与CPU资源之间取舍的折中方案但这个策略不会带来显著的延迟抖动。

PhasedBackoffWaitStrategy实现方法是先自旋(10000次)不行再临时让出调度(yield)不行再使用其他的策略进行等待。可以根据具体场景自行设置自旋时间、yield时间和备用等待策略。

 

ProducerType.SINGLE  表示的是单生产者的情况，如果是多生产者，使用的是ProducerType.MULTI

 

多消费者之间的依赖关系

（1）如果是单生产者单消费者，则很简单

//单生产者模式，单消费者模式
    public static void main(String[] args) throws Exception {
        EventFactory<Order> factory = new OrderFactory();
        int ringBufferSize = 1024 * 1024;
        Disruptor<Order> disruptor =
                new Disruptor<Order>(factory, ringBufferSize, Executors.defaultThreadFactory(), ProducerType.SINGLE, new YieldingWaitStrategy());
        //设置一个消费者
        disruptor.handleEventsWith(new OrderHandlerPlus("1"));
        disruptor.start();
        RingBuffer<Order> ringBuffer = disruptor.getRingBuffer();
        Producer producer = new Producer(ringBuffer);
        //单生产者，生产5条数据
        for (int l = 0; l < 5; l++) {
        	long number = 10+l;
            producer.onData(l,number);
        }
        Thread.sleep(1000);
        disruptor.shutdown();
    }

 

输出结果如下：

（2）四个（菱形）消费者之间的依赖关系

public class MainOneProduceMultiC {
	 //单生产者，多消费者，但多消费者间形成依赖关系，每个依赖节点单线程。
    public static void main(String[] args) throws Exception {
        EventFactory<Order> factory = new OrderFactory();
        int ringBufferSize = 1024 * 1024;
        Disruptor<Order> disruptor =
                new Disruptor<Order>(factory, ringBufferSize, Executors.defaultThreadFactory(), ProducerType.SINGLE, new YieldingWaitStrategy());
        //多个消费者间形成依赖关系，每个依赖节点的消费者为单线程。
        disruptor.handleEventsWith(new OrderHandlerPlus("1")).then(new OrderHandlerMulti("2"), new OrderHandlerPlusTwenty("3")).then(new OrderHandlerMultiTwenty("4"));
        disruptor.start();
        RingBuffer<Order> ringBuffer = disruptor.getRingBuffer();
        Producer producer = new Producer(ringBuffer);
        //单生产者，生产3条数据
        for (int l = 0; l < 3; l++) {
        	long number = 10+l;
            producer.onData(l,number);
        }
        Thread.sleep(1000);
        disruptor.shutdown();
    }

}

四个消费者之间的依赖图如下：

消费者C2、C3只有在C1执行完m后，才能执行m。消费者C4只有在C2、C3执行完m后，才能执行。

可能的输出结果如下（可能因为线程执行先后顺序不同略有区别，但输出一定满足相关依赖约束）：

 

 

（3）五个消费者之间的依赖关系

public class MainOneProduceMultiC3 {
	//单生产者，多消费者模式。消费者1、2独立消费每一条消息，消费者3、4不重复消费消费者1、2均处理过的消息，消费者5消费消费者3或4消费过的消息
    public static void main(String[] args) throws Exception {
        EventFactory<Order> factory = new OrderFactory();
        int ringBufferSize = 1024 * 1024;
        Disruptor<Order> disruptor =
                new Disruptor<Order>(factory, ringBufferSize, Executors.defaultThreadFactory(), ProducerType.SINGLE, new YieldingWaitStrategy());
        disruptor.handleEventsWith(new OrderHandlerPlus("1"), new OrderHandlerMulti("2")).thenHandleEventsWithWorkerPool(new OrderHandlerPlusTwenty("3"), new OrderHandlerMultiTwenty("4")).then(new OrderHandlerPlusHundred("5"));
        disruptor.start();
        RingBuffer<Order> ringBuffer = disruptor.getRingBuffer();
        Producer producer = new Producer(ringBuffer);
        //单生产者，生产3条数据
        for (int l = 0; l < 3; l++) {
        	long number = 10+l;
            producer.onData(l,number);
        }
        Thread.sleep(1000);
        disruptor.shutdown();
    }

}

消费者间的依赖图如下：

可能的输出结果如下：

（4）多个生产者单个消费者

public class MainMultiProduceOneC {
	//多生产者，单消费者版本。三个生产者独立生产消息。
    public static void main(String[] args) throws Exception {
        EventFactory<Order> factory = new OrderFactory();
        int ringBufferSize = 1024 * 1024;
        //ProducerType要设置为MULTI，后面才可以使用多生产者模式
        Disruptor<Order> disruptor =
                new Disruptor<Order>(factory, ringBufferSize, Executors.defaultThreadFactory(), ProducerType.MULTI, new YieldingWaitStrategy());
        //简化问题，设置为单消费者模式，也可以设置为多消费者及消费者间多重依赖。
        disruptor.handleEventsWith(new OrderHandlerPlusString("1"));
//        disruptor.handleEventsWith(new OrderHandlerPlusString("1")).then(new OrderHandlerMultiString("2"));
        disruptor.start();
        final RingBuffer<Order> ringBuffer = disruptor.getRingBuffer();
        //判断生产者是否已经生产完毕
        final CountDownLatch countDownLatch = new CountDownLatch(3);
        //单生产者，生产3条数据
        for (int l = 0; l < 3; l++) {
            Thread thread = new Thread() {
                @Override
                public void run() {
                    for(int i = 0; i < 3; i++) {
                    	long number = 10+i;
                        new Producer(ringBuffer).onDataMultiProduceS(i,Thread.currentThread().getName(),number);
                    }
                    countDownLatch.countDown();
                }
            };
            thread.setName("producer thread " + l);
            thread.start();
        }
        countDownLatch.await();
        Thread.sleep(1000);
        disruptor.shutdown();
    }

}

可能输出如下：

（5）多个生产者，多个消费者

disruptor.handleEventsWith(new OrderHandlerPlusString("1"),new OrderHandlerMultiString("2"));