健网站怎么做/网络营销建议

本文将介绍Disruptor的工作机制，并分析Disruptor的主要源码

基于的版本是3.3.7（发布于2017.09.28）

水平有限，如有谬误请留言指正

 

0. 什么是Disruptor？

Disruptor是一个开源的并发框架，提供了类似于Java中有界队列的功能，主要用于生产消费者场景。

与Java原生并发队列不同的是，Disruptor高度优化，在单机上可以轻松跑到千万级别的tps与ns级别的延时

 

1. Disruptor的关键想法

a. 使用环形队列作为底层存储（存储空间连续，可以充分利用cache）

b. 环形队列中存储的对象都是预先建立好的，减少了频繁创建/释放对象带来的开销

c. 生产者使用两阶段提交的方式来发布事件（第一阶段是先在环形队列中预占一个空位，第二阶段是向这个空位中写入数据，竞争只发生在第一阶段），并使用CAS操作来解决冲突，而不是使用昂贵的Lock

d. 用cache line padding（缓冲区填充）的思想来解决false sharing（伪共享）的问题

e. 使用了Java底层的Unsafe操作

 

2. Disruptor的核心组件

RingBuffer

环形缓冲区，本质是一个定长Object数组（后续称里面的格子为slot），为了避免伪共享，在这个数组的两端额外填充了若干空位（这也导致访问RingBuffer数据的方式比较崎岖，具体请自行参见源码）

Sequence

类似于AtomicLong，用于标记事件id

所有生产者共用一个Sequence，用于不冲突的将事件放到RingBuffer上

每个消费者自己维护一个Sequence，用于标记自己当前正在处理的事件的id

Sequencer

生产者访问RingBuffer时的控制器，主要实现有两种：SingleProducerSequencer与MultiProducerSequencer，分别用于单生产者和多生产者的场景

SequenceBarrier

只有一个实现类为ProcessingSequenceBarrier，用于协调生产者与消费者（如果某个slot中的事件还没有被所有消费者消费完毕，那么这个slot是不能被复用的，需要等待）

WaitStrategy

消费者等待下一个可用事件的策略，Disruptor自带了多种WaitStrategy的实现，可以根据场景自行选择。

 

3. 生产者发布事件到RingBuffer

示例代码如下：

        long sequence = ringBuffer.next();  // 第一阶段，获取RingBuffer上下一个可用的slot的序列号，这里可能会有争用try {Event event = ringBuffer.get(sequence); // 根据序列号直接去RingBuffer上获取对应的slot上存储的事件event.setData(data);  // 写入数据} finally {ringBuffer.publish(sequence); // 第二阶段，将这个事件正式发布到RingBuffer中}

需要重点关注的是next()与publish()方法

next()方法

RingBuffer的next方法直接调用关联的Sequencer的next方法，Sequencer的实现又分为SingleProducerSequencer与MultiProducerSequencer这两种

先从相对简单的单生产者SingleProducerSequencer看起：

SingleProducerSequencer.next()@Overridepublic long next(){return next(1);}@Overridepublic long next(int n){if (n < 1)//参数检验
        {throw new IllegalArgumentException("n must be > 0");}long nextValue = this.nextValue;//上一次返回的seqlong nextSequence = nextValue + n;//这次应该返回的序列值，这个序列值还未被产生，对应的slot里的元素的seq需要减去RingBuffer的大小long wrapPoint = nextSequence - bufferSize;//这个序列值对应的slot上正在存储的元素的seq，这个slot可能已经被消费了，也可能没有long cachedGatingSequence = this.cachedValue;//获取消费者未消费的元素的seq最小值，这个值不是实时的//wrapPoint > cachedGatingSequence，检查将要被放入元素的slot是否已经没有消费者占用了//cachedGatingSequence > nextValue，用于来应对seq发生溢出的情况if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue){cursor.setVolatile(nextValue);  // StoreLoad fence，更新RingBuffer的游标，用到了Unsafe方法long minSequence;//Util.getMinimumSequence可以获得所有消费者未消费事件的seq最小值，在比这个值更小的slot里发布元素是安全的//如果这个判断成立，说明生产者正在试图将元素放到消费者未消费完毕的slot里，这个操作是不安全的，生产者需要在这里被阻塞while (wrapPoint > (minSequence = Util.getMinimumSequence(gatingSequences, nextValue))){waitStrategy.signalAllWhenBlocking();//激活所有的消费者（避免有的消费者睡死过去了）LockSupport.parkNanos(1L); // TODO: Use waitStrategy to spin? 自旋等待
            }this.cachedValue = minSequence;//更新cachedValue
        }this.nextValue = nextSequence;return nextSequence;}

逻辑比较难懂，关键之处如下：

a. 返回的seq对应的slot必须已经被所有消费者消费完毕

b. Util.getMinimumSequence会遍历所有消费者使用的Sequence，并获取其最小值，这是一个比较昂贵的操作，所以将其缓存在本地的cachedValue变量中

c. 如果seq对应的slot还没被消费者消费完毕，说明生产速度快于消费速度，生产者需要原地自旋等待，同时向消费者发送信号，避免消费者睡死过去的情况

再来看多生产者版本：

    @Overridepublic long next(int n){if (n < 1)//参数检验
        {throw new IllegalArgumentException("n must be > 0");}long current;long next;do{current = cursor.get();//获取最新返回的seqnext = current + n;//本次返回的seqlong wrapPoint = next - bufferSize;//本次返回的seq对应的slot里的元素的seqlong cachedGatingSequence = gatingSequenceCache.get();//有多个生产者，gatingSequenceCache实际上是SingleProducerSequencer里的cachedValue的Atomic版本if (wrapPoint > cachedGatingSequence || cachedGatingSequence > current)//检查将要被放入元素的slot是否已经没有消费者占用了
            {long gatingSequence = Util.getMinimumSequence(gatingSequences, current);//获得所有消费者未消费事件的seq最小值if (wrapPoint > gatingSequence)//slot仍被消费者占用，生产者自旋等待
                {waitStrategy.signalAllWhenBlocking();LockSupport.parkNanos(1); // TODO, should we spin based on the wait strategy?continue;}gatingSequenceCache.set(gatingSequence);//更新gatingSequenceCache的值
            }else if (cursor.compareAndSet(current, next))//用CAS操作更新cursor的值，如果失败了说明有其他生产者在争用，进入下一轮循环
            {break;}}while (true);return next;}

与单生产者版本类似，但是当前序列值以及缓存住的安全序列值都使用了原子变量，以解决线程安全问题。可以说是非常精巧了。

至于publish方法

SingleProducerSequencer.publish@Overridepublic void publish(long sequence){cursor.set(sequence);//更新RingBuffer的游标waitStrategy.signalAllWhenBlocking();//给消费者发送signal信号，具体怎么做与waitStrategy的实现有关
    }MultiProducerSequencer.publish@Overridepublic void publish(final long sequence){setAvailable(sequence);//这里用了一个额外的availableBuffer数组，来标记RingBuffer的某个slot是否已经被publish成功，后面生产者消费的时候会用到waitStrategy.signalAllWhenBlocking();//给消费者发送signal信号，具体怎么做与waitStrategy的实现有关}

单生产者/多生产者之间微妙的区别：

单生产者publish一个seq，那么这个seq之前所有的seq都被publish了

多生产者publish一个seq，那么只有这一个seq被publish

 

4. 消费者从RingBuffer获取数据

消费者是通过调用Disruptor的handlerEventsWith方法被添加到系统中的，其调用链如下：

Disruptor.handleEventsWith()public EventHandlerGroup<T> handleEventsWith(final EventHandler<? super T>... handlers){return createEventProcessors(new Sequence[0], handlers);//添加事件处理器，
    }Disruptor.createEventProcessors()EventHandlerGroup<T> createEventProcessors(final Sequence[] barrierSequences,//默认情况下，barrierSequences是不存在的final EventHandler<? super T>[] eventHandlers){checkNotStarted();final Sequence[] processorSequences = new Sequence[eventHandlers.length];//为每个消费者创建一个Sequencefinal SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences);//创建一个与当前RingBuffer的生产者有关的Barrierfor (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++)//遍历消费者
        {final EventHandler<? super T> eventHandler = eventHandlers[i];final BatchEventProcessor<T> batchEventProcessor =new BatchEventProcessor<T>(ringBuffer, barrier, eventHandler);//为每个消费者创建一个BatchEventProcessorif (exceptionHandler != null){batchEventProcessor.setExceptionHandler(exceptionHandler);//异常处理器
            }consumerRepository.add(batchEventProcessor, eventHandler, barrier);//将EventHandler与BatchEventProcessor关联起来processorSequences[i] = batchEventProcessor.getSequence();}updateGatingSequencesForNextInChain(barrierSequences, processorSequences);//将消费者的sequence添加为RingBuffer的gating sequencereturn new EventHandlerGroup<T>(this, consumerRepository, processorSequences);}

 

然后调用Disruptor的start方法启动系统，其调用链如下：

Disruptor.start()public RingBuffer<T> start(){checkOnlyStartedOnce();for (final ConsumerInfo consumerInfo : consumerRepository)//遍历注册的所有消费者
        {consumerInfo.start(executor);}return ringBuffer;}EventProcessorInfo.start()@Overridepublic void start(final Executor executor){executor.execute(eventprocessor);//这里是将之前在createEventProcessors中为消费者注册的BatchEventProcessor放到线程池里运行起来了
    }BatchEventProcessor.run()@Overridepublic void run(){if (!running.compareAndSet(false, true))//避免重复运行
        {throw new IllegalStateException("Thread is already running");}sequenceBarrier.clearAlert();notifyStart();T event = null;long nextSequence = sequence.get() + 1L;try{while (true)//在死循环中处理事件
            {try{final long availableSequence = sequenceBarrier.waitFor(nextSequence);//从RingBuffer中获取一批可以处理的事件的seq，策略由之前设置的waitStrategy决定，返回的seq可能会大于nextSequence（批量，提高效率）if (batchStartAware != null){batchStartAware.onBatchStart(availableSequence - nextSequence + 1);}while (nextSequence <= availableSequence)//在循环中消耗返回的availableSequence
                    {event = dataProvider.get(nextSequence);//从RingBuffer中读取数据eventHandler.onEvent(event, nextSequence, nextSequence == availableSequence);//调用用户传入的EventHandler中的onEvent方法来处理事件nextSequence++;}sequence.set(availableSequence);//这一批seq消耗完了，更新当前消费者关联的sequence，让生产者可以知道，这里调用的是相对廉价的putOrderedLong方法，因为不需要很高的实时性
                }catch (final TimeoutException e){notifyTimeout(sequence.get());}catch (final AlertException ex){if (!running.get()){break;}}catch (final Throwable ex){exceptionHandler.handleEventException(ex, nextSequence, event);sequence.set(nextSequence);nextSequence++;}}}finally{notifyShutdown();running.set(false);}}ProcessingSequenceBarrier.waitFor()public long waitFor()(final long sequence)throws AlertException, InterruptedException, TimeoutException{checkAlert();long availableSequence = waitStrategy.waitFor(sequence, cursorSequence, dependentSequence, this);//调用消费者的waitStrategy来等待sequence变得可用if (availableSequence < sequence){return availableSequence;}return sequencer.getHighestPublishedSequence(sequence, availableSequence);//从RingBuffer中找到最大的已经被publish事件的slot，寻找策略根据单生产者/多生产者有不同
    }SingleProducerSequencer.getHighestPublishedSequence()//单生产者的情况，简单public long getHighestPublishedSequence(long lowerBound, long availableSequence){return availableSequence;}MultiProducerSequencer.getHighestPublishedSequence()//多生产者public long getHighestPublishedSequence(long lowerBound, long availableSequence){for (long sequence = lowerBound; sequence <= availableSequence; sequence++)//从lowerBound开始遍历，在RingBuffer中找到最大的已经被publish事件的slot
        {if (!isAvailable(sequence)){return sequence - 1;}}return availableSequence;}public boolean isAvailable(long sequence){int index = calculateIndex(sequence);//在RingBuffer中定位int flag = calculateAvailabilityFlag(sequence);//后面的3行是在availableBuffer数组中寻找对应位置的元素是否被标记为available。在MultiProducerSequencer的publish方法中会做这一操作long bufferAddress = (index * SCALE) + BASE;return UNSAFE.getIntVolatile(availableBuffer, bufferAddress) == flag;}

这一块的代码也比较难，做个小结：

a. 每个消费者都与一个BatchEventProcessor关联，BatchEventProcessor初始化的时候会创建一个sequence，这个sequence记录的是消费者已经处理的事件的seq

b. Disruptor初始化的时候会创建一个SequenceBarrier，这个barrier与生产者有关

c. 消费者会无限的调用barrier的waitFor方法，以尝试获取最新publish的事件，一旦waitFor方法返回了可用的seq，就在循环中调用消费者的onEvent方法将这些事件消耗掉

d. 在waitFor方法中，会根据设定的WaitStrategy来在RingBuffer上查找最新publish的事件的seq

 

5. WaitStrategy

WaitStrategy在消费速度快于生产速度，消费者等待生产者publish新的事件时会被用到。

如果生产速度快于消费速度，生产者等待消费者时，用的是LockSupport.parkNanos(1)，类似于自旋等待。

WaitStrategy非常重要，不同的WaitStrategy会直接影响到响应事件和CPU占用，值得专门开一节来分析

WaitStrategy是一个接口，其中只含有两个方法：

    //sequence：消费者等待这个sequence关联的事件产生//cursor：RingBuffer上，生产者关联的Sequence//dependentSequence：默认情况下与cursor相同//barrier：与生产者关联的barrierlong waitFor(long sequence, Sequence cursor, Sequence dependentSequence, SequenceBarrier barrier)throws AlertException, InterruptedException, TimeoutException;void signalAllWhenBlocking();//如果有消费者阻塞等待，将其唤醒

 

WaitStrategy有多种实现，我这里只分析两种最有代表性的：BlockingWaitStrategy与BusySpinWaitStrategy

BlockingWaitWaitStrategy的实现如下：

    private final Lock lock = new ReentrantLock();//锁与关联的条件private final Condition processorNotifyCondition = lock.newCondition();@Overridepublic long waitFor(long sequence, Sequence cursorSequence, Sequence dependentSequence, SequenceBarrier barrier)throws AlertException, InterruptedException{long availableSequence;if (cursorSequence.get() < sequence)//如果生产者还没有生产出足够的事件，那么在锁上等待
        {lock.lock();//尝试占有锁try{while (cursorSequence.get() < sequence){barrier.checkAlert();processorNotifyCondition.await();//等待
                }}finally{lock.unlock();//释放锁
            }}while ((availableSequence = dependentSequence.get()) < sequence){barrier.checkAlert();}return availableSequence;}@Overridepublic void signalAllWhenBlocking(){lock.lock();try{processorNotifyCondition.signalAll();//唤醒所有在锁上等待的生产者
        }finally{lock.unlock();}}

代码很简单，用JDK自带的ReentrantLock与Condition来完成消费者的等待控制，只要消费者拿不到可用的事件，就调用Condition.await方法等待

好处：CPU占用少

坏处：在生产的事件足够后，消费者无法在第一时间醒来，需要生产者调用signalAll才行，由于此时消费者线程可能已经被OS切走了，这会带来一定的延时

BusySpinWaitStrategy的实现如下：

    @Overridepublic long waitFor(final long sequence, Sequence cursor, final Sequence dependentSequence, final SequenceBarrier barrier)throws AlertException, InterruptedException{long availableSequence;while ((availableSequence = dependentSequence.get()) < sequence)//只要生产者没有生产出足够的事件，消费者就一直自旋等待
        {barrier.checkAlert();}return availableSequence;}@Overridepublic void signalAllWhenBlocking()//消费者根本不被阻塞，所以无需唤醒
    {}

这个等待策略就更简单了，甚至可以说是丧心病狂，所有消费者都在无限自旋等待（Busy Spin），直到生产者生产了足够的事件为止。

好处：延时极低（消费者线程一直是热的），生产出来的事件会第一时间被消费掉

坏处：有多少个消费者，就会吃满多少个Core

小结一下：

WaitStrategy实际上是延时与CPU资源占用的权衡

如果你追求最低的延时（ns级别），那就必须保证消费者一直是是热的，不能被系统调度走，因此你需要BusySpinWaitStrategy

如果你不需要那么低的延时，那么基于锁的BlockingWaitStrategy可能更加适合你

 

 6. Disruptor与ArrayBlockingQueue的比较

ArrayBlockingQueue的源码分析可以参见这篇博客，其核心想法如下：

a. 内置一个ReentrantLock与两个Condition

b. 任何对Queue的读写操作均用ReentrantLock加锁 -> 实现了线程安全的语义

c. 在队列空/满的情况下如果继续取出/插入元素，则利用Condition将工作线程阻塞，在符合条件的时候再将被阻塞的线程唤醒 -> 实现了阻塞队列的语义

很明显，这种实现在高并发的情况下存在一定的问题：

a. 在任一时刻，只能有一个读/写线程在工作，其他的线程都被ReentrantLock所阻塞

b. takeIndex与putIndex这两个被频繁访问的域在内存上距离很近，容易引起伪共享问题

Disruptor则很好的解决了这些问题，具体请参加本文第一节

 

7. 总结

Disruptor是一个设计非常精巧的框架，为了追求极致性能，做了很多底层优化，值得学习参考

 

参考资料

并发编程网上关于Disruptor的系列文章

高性能队列——Disruptor