Disruptor源码解读

 

上一篇已经介绍了Disruptor是什么？简单总结了为何这么快？下面咱们直接源码搞起来，简单粗暴。
高性能队列disruptor为何这么快？

 

1、核心类接口

Disruptor 提供了对RingBuffer的封装。

RingBuffer 环形队列，基于数组实现，内存被循环使用，减小了内存分配、回收扩容等操做。

EventProcessor 事件处理器，实现了Runnable，单线程批量处理BatchEventProcessor和多线程处理WorkProcessor。

Sequencer 生产者访问序列的接口，RingBuffer生产者的父接口，其直接实现有SingleProducerSequencer和MultiProducerSequencer。

EventSequencer 空接口，暂时没用，用于之后扩展。

SequenceBarrier 消费者屏障 消费者用于访问缓存的控制器。

WaitStrategy 当没有可消费的事件时，根据特定的实现进行等待。

SingleProducerSequencer 单生产者发布实现类

MultiProducerSequencer 多生产者发布实现类

笔者简单介绍下经常使用的类，看不懂不要紧，等看完源码天然明白。

核心类源码分析已经上传了git地址：https://github.com/Sonion/disroptor

2、生产者

开局一张图，走起。

想分析disruptor，先看生产者，这是笔者整理的生产者相关类图。

单生产者发布流程：

生产者发布消息是从Disruptor的publish方法开始，

//Disruptor.java
public <A> void publishEvent(final EventTranslatorOneArg<T, A> eventTranslator, final A arg)
{
　　ringBuffer.publishEvent(eventTranslator, arg);
}

实际调用的RingBuffer的publishEvent，实际上也就是作两件事，一先去获取RingBuffer上的一个可用位置，第二步在可用位置上发布数据。

//RingBuffer.java   
public <A> void publishEvent(EventTranslatorOneArg<E, A> translator, A arg0)
{
　　final long sequence = sequencer.next();
　　translateAndPublish(translator, sequence, arg0);
}

来看看获取RingBuffer上的一个可用位置，先看看单生产者SingleProducerSequencer.next()方法。

 //SingleProducerSequencer.java   
    /**
     * @see Sequencer#next()
     */
    @Override
    public long next()
    {
        return next(1);
    }

    /**
     * @see Sequencer#next(int)
     */
    @Override
    public long next(int n)
    {
        if (n < 1 || n > bufferSize)
        {
            throw new IllegalArgumentException("n must be > 0 and < bufferSize");
        }
        // 获取上次申请最后的序列值
        long nextValue = this.nextValue;
        // n=1,获得本次须要申请的序列值
        long nextSequence = nextValue + n;
        // 可能发生绕环的点，本次申请值 - 环形一圈长度
        long wrapPoint = nextSequence - bufferSize;
        // 数值最小的序列值，理解为最慢消费者
        long cachedGatingSequence = this.cachedValue;
        // 序列值初始值是 -1 ，只有wrapPoint 大于 cachedGatingSequence 将发生绕环行为，生产者超一圈从后方追上消费者，生产者覆盖未消费的状况。
        // 没有空坑位，将进入循环等待。
        if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue)
        {
            cursor.setVolatile(nextValue);  // StoreLoad fence

            long minSequence;
            // 只有当消费者消费，向前移动后，才能跳出循环
            // 每次从新获取消费者序列最小值进行轮询判断
            while (wrapPoint > (minSequence = Util.getMinimumSequence(gatingSequences, nextValue)))
            {
                LockSupport.parkNanos(1L);
            }
            // 当消费者消费后，更新缓存的最小序号
            this.cachedValue = minSequence;
        }
        // 将成功申请的序号赋值给对象实例变量
        this.nextValue = nextSequence;

        return nextSequence;
    }

next获取能够写入的序列号，回到RingBuffer的publishEvent方法，执行translateAndPublish方法，进行发布操做。

//RingBuffer.java   
     private void translateAndPublish(EventTranslator<E> translator, long sequence)
    {
        try
        {
            translator.translateTo(get(sequence), sequence);
        }
        finally
        {
            sequencer.publish(sequence);
        }
    }

 translator.translateTo()对EventTranslator接口的实现。将数据放置好，进行发布。

//SingleProducerSequencer.java  
  /**
     * @see Sequencer#publish(long)
     */
    @Override
    public void publish(long sequence)
    {
        // 更新Sequencer内部游标值
        cursor.set(sequence);
        // 当生产者发布新事件后，将通知等待的EventProcessor,能够进行消费
        waitStrategy.signalAllWhenBlocking();
    }

// BlockingWaitStrategy.java
    @Override
    public void signalAllWhenBlocking()
    {
        synchronized (mutex)
        {
            mutex.notifyAll();
        }
    }

到此单生产者发布流程已经讲完。仍是那句话，很简单，两步操做先去获取RingBuffer上的一个可用位置，第二步在可用位置上发布数据。

多生产者发布流程：

咱们简单看下，前面和单生产者发布流程同样，实现接口AbstractSequencer，仍是next()方法，咱们来看。

//MultiProducerSequencer.java
    /**
     * @see Sequencer#next()
     */
    @Override
    public long next()
    {
        return next(1);
    }

    /**
     * @see Sequencer#next(int)
     */
    @Override
    public long next(int n)
    {
        if (n < 1 || n > bufferSize)
        {
            throw new IllegalArgumentException("n must be > 0 and < bufferSize");
        }

        long current;
        long next;

        do
        {
            // 当前游标值，初始化时是-1
            current = cursor.get();
            next = current + n;

            long wrapPoint = next - bufferSize;
            long cachedGatingSequence = gatingSequenceCache.get();

            if (wrapPoint > cachedGatingSequence || cachedGatingSequence > current)
            {
                long gatingSequence = Util.getMinimumSequence(gatingSequences, current);

                if (wrapPoint > gatingSequence)
                {
                    LockSupport.parkNanos(1); // TODO, should we spin based on the wait strategy?
                    continue;
                }

                gatingSequenceCache.set(gatingSequence);
            }
            else if (cursor.compareAndSet(current, next))
            {
                break;
            }
        }
        while (true);

        return next;
    }

能够看到多生产者发布流程和单生产者发布流程区别不大，最后固然仍是调用publish发布，publish有点区别，咱们来看。

    /**
     * @see Sequencer#publish(long)
     */
    @Override
    public void publish(final long sequence)
    {
        //多生产者是采用availableBuffer数组设置
        setAvailable(sequence);

        waitStrategy.signalAllWhenBlocking();
    }

    /**
     * @see Sequencer#publish(long, long)
     */
    @Override
    public void publish(long lo, long hi)
    {
        for (long l = lo; l <= hi; l++)
        {
            setAvailable(l);
        }
        waitStrategy.signalAllWhenBlocking();
    }

对比SingleProducerSequencer的publish，MultiProducerSequencer的publish没有设置cursor，而是将内部使用的availableBuffer数组对应位置进行设置。availableBuffer是一个记录RingBuffer槽位状态的数组，经过对序列值sequence&bufferSize-1，得到槽位号，再经过位运算，获取序列值所在的圈数，进行设置。使用更高效的位与和右移操做。

    private void setAvailable(final long sequence)
    {
        // calculateIndex 与&， calculateAvailabilityFlag 移位操做
        setAvailableBufferValue(calculateIndex(sequence), calculateAvailabilityFlag(sequence));
    }

    private void setAvailableBufferValue(int index, int flag)
    {
        // 使用Unsafe更新属性，由于是直接操做内存，因此须要计算元素位置对应的内存位置buffer地址
        long bufferAddress = (index * SCALE) + BASE;
        // availableBuffer是标志可用位置的int数组，初始全为-1
        UNSAFE.putOrderedInt(availableBuffer, bufferAddress, flag);
    }

     private int calculateAvailabilityFlag(final long sequence)
    {
        return (int) (sequence >>> indexShift);
    }

    private int calculateIndex(final long sequence)
    {
        return ((int) sequence) & indexMask;
    }

到此，多生产者发布流程也讲完了，是否是很easy，若是你们有问题，评论区咱们一块儿讨论。

3、消费者

老规矩，再来一张图，这个就比较简单了。

EventProcessor是整个消费者事件处理框架，EventProcessor接口继承了Runnable接口，主要有两种实现：单线程批量处理BatchEventProcessor和多线程处理WorkProcessor。
在使用Disruptor帮助类构建消费者时，使用handleEventsWith方法传入多个EventHandler，内部使用多个BatchEventProcessor关联多个线程执行。这种状况相似JMS中的发布订阅模式，同一事件会被多个消费者并行消费。适用于同一事件触发多种操做。
而使用Disruptor的handleEventsWithWorkerPool传入多个WorkHandler时，内部使用多个WorkProcessor关联多个线程执行。这种状况相似JMS的点对点模式，同一事件会被一组消费者其中之一消费。适用于提高消费者并行处理能力。

BatchEventProcessor单线程批处理事件(理解为广播消费，重复消费)

// EventHandlerGroup.java
public EventHandlerGroup<T> then(final EventHandler<? super T>... handlers)
{
    return handleEventsWith(handlers);
}
public EventHandlerGroup<T> handleEventsWith(final EventHandler<? super T>... handlers)
{
    return disruptor.createEventProcessors(sequences, handlers);
}

 

//Disruptor.java
    // barrierSequences是EventHandlerGroup实例的序列，就是上一个事件处理者组的序列
    EventHandlerGroup<T> createEventProcessors(
        final Sequence[] barrierSequences,
        final EventHandler<? super T>[] eventHandlers)
    {
        checkNotStarted();
        // processorSequences本次事件处理器组的序列组
        final Sequence[] processorSequences = new Sequence[eventHandlers.length];
        final SequenceBarrier barrier = ringBuffer.newBarrier(barrierSequences);

        for (int i = 0, eventHandlersLength = eventHandlers.length; i < eventHandlersLength; i++)
        {
            final EventHandler<? super T> eventHandler = eventHandlers[i];

            final BatchEventProcessor<T> batchEventProcessor =
                new BatchEventProcessor<>(ringBuffer, barrier, eventHandler);

            if (exceptionHandler != null)
            {
                batchEventProcessor.setExceptionHandler(exceptionHandler);
            }

            consumerRepository.add(batchEventProcessor, eventHandler, barrier);
            processorSequences[i] = batchEventProcessor.getSequence();
        }
        // 每次添加完事件处理器后，更新门控序列，用于后续调用链的添加判断。
        updateGatingSequencesForNextInChain(barrierSequences, processorSequences);

        return new EventHandlerGroup<>(this, consumerRepository, processorSequences);
    }

    // 门控，是指后续消费链的消费，不能超过前边。
    private void updateGatingSequencesForNextInChain(final Sequence[] barrierSequences, final Sequence[] processorSequences)
    {
        if (processorSequences.length > 0)
        {
            //GatingSequences一直保存消费链末端消费者的序列组
            ringBuffer.addGatingSequences(processorSequences);
            for (final Sequence barrierSequence : barrierSequences)
            {
                ringBuffer.removeGatingSequence(barrierSequence);
            }
            // 取消标记上一组消费者为消费链末端
            consumerRepository.unMarkEventProcessorsAsEndOfChain(barrierSequences);
        }
    }

 

BatchEventProcessor构建消费者链时的逻辑都在createEventProcessors这个方法中。

先简单说下ConsumerRepository，这个类主要保存消费者的各类关系，如经过EventHandler引用获取EventProcessorInfo信息，经过Sequence获取ConsumerInfo信息等。

由于要使用引用作key，因此数据结构使用IdentityHashMap。

• IdentityHashMap使用的是==比较key的值，而HashMap使用的是equals()
• HashMap使用的是hashCode()查找位置，IdentityHashMap使用的是System.identityHashCode(object)
• IdentityHashMap理论上来讲速度要比HashMap快一点

• 另一点呢就是IdentityHashMap中key能重复，但须要注意一点的是key比较的方法是==，因此若要存放两个相同的key，就须要存放不一样的地址。

这个createEventProcessors方法接收两个参数，barrierSequences表示当前消费者组的屏障序列数组，若是当前消费者组是第一组，则取一个空的序列数组；不然，barrierSequences就是上一组消费者组的序列数组。createEventProcessors方法的另外一个参数eventHandlers，这个参数是表明事件消费逻辑的EventHandler数组。
Disruptor为每一个EventHandler实现类都建立了一个对应的BatchEventProcessor，全部消费者共用一个SequenceBarrier。
在构建BatchEventProcessor时须要如下传入三个构造参数：dataProvider是数据存储结构如RingBuffer；sequenceBarrier用于跟踪生产者游标，协调数据处理；eventHandler是用户实现的事件处理器，也就是实际的消费者。

//BatchEventProcessor.java
    @Override
    public void run()
    {
        if (running.compareAndSet(IDLE, RUNNING))
        {
            sequenceBarrier.clearAlert();

            notifyStart();
            try
            {
                if (running.get() == RUNNING)
                {
                    processEvents();
                }
            }
            finally
            {
                notifyShutdown();
                running.set(IDLE);
            }
        }
        else
        {
            // This is a little bit of guess work.  The running state could of changed to HALTED by
            // this point.  However, Java does not have compareAndExchange which is the only way
            // to get it exactly correct.
            if (running.get() == RUNNING)
            {
                throw new IllegalStateException("Thread is already running");
            }
            else
            {
                earlyExit();
            }
        }
    }

    private void processEvents()
    {
        T event = null;
        long nextSequence = sequence.get() + 1L;

        while (true)
        {
            try
            {
                // 当前可以使用的最大值
                // 使用给定的等待策略去等待下一个序列可用
                final long availableSequence = sequenceBarrier.waitFor(nextSequence);
                if (batchStartAware != null)
                {
                    batchStartAware.onBatchStart(availableSequence - nextSequence + 1);
                }

                // 批处理
                // 消费的偏移量大于上次消费记录
                while (nextSequence <= availableSequence)
                {
                    event = dataProvider.get(nextSequence);
                    eventHandler.onEvent(event, nextSequence, nextSequence == availableSequence);
                    nextSequence++;
                }

                // eventHandler处理完毕后，更新当前序号
                sequence.set(availableSequence);
            }
            catch (final TimeoutException e)
            {
                notifyTimeout(sequence.get());
            }
            catch (final AlertException ex)
            {
                if (running.get() != RUNNING)
                {
                    break;
                }
            }
            catch (final Throwable ex)
            {
                exceptionHandler.handleEventException(ex, nextSequence, event);
                sequence.set(nextSequence);
                nextSequence++;
            }
        }
    }

咱们再来看看SequenceBarrier实现类ProcessingSequenceBarrier的代码是如何实现waitFor方法。

final class ProcessingSequenceBarrier implements SequenceBarrier
{
    /**
     * 等待可用消费时，指定的等待策略
     */
    private final WaitStrategy waitStrategy;
    /**
     * 依赖的上组消费者的序号，若是当前为第一组则为cursorSequence（即生产者发布游标序列）
     * 不然使用FixedSequenceGroup封装上组消费者序列
     */
    private final Sequence dependentSequence;
    /**
     * 当触发halt时，将标记alerted为true
     */
    private volatile boolean alerted = false;
    /**
     * AbstractSequencer中的cursor引用，记录当前发布者发布的最新位置
     */
    private final Sequence cursorSequence;
    /**
     * MultiProducerSequencer 或 SingleProducerSequencer
     */
    private final Sequencer sequencer;

    ProcessingSequenceBarrier(
        final Sequencer sequencer,
        final WaitStrategy waitStrategy,
        final Sequence cursorSequence,
        final Sequence[] dependentSequences)
    {
        this.sequencer = sequencer;
        this.waitStrategy = waitStrategy;
        this.cursorSequence = cursorSequence;
        // 依赖的上一组序列长度，第一次是0
        if (0 == dependentSequences.length)
        {
            dependentSequence = cursorSequence;
        }
        // 将上一组序列数组复制成新数组保存，引用不变
        else
        {
            dependentSequence = new FixedSequenceGroup(dependentSequences);
        }
    }

    @Override
    public long waitFor(final long sequence)
        throws AlertException, InterruptedException, TimeoutException
    {
        // 检查是否中止服务
        checkAlert();
        // 获取最大可用序号 sequence为给定序号，通常为当前序号+1，cursorSequence记录生产者最新位置，
        long availableSequence = waitStrategy.waitFor(sequence, cursorSequence, dependentSequence, this);

        if (availableSequence < sequence)
        {
            return availableSequence;
        }
        // 返回已发布最高的序列值，将对每一个序号进行校验
        return sequencer.getHighestPublishedSequence(sequence, availableSequence);
    }

咱们再来看看等待策略WaitStrategy#waitFor

//BlockingWaitStrategy.java
public final class BlockingWaitStrategy implements WaitStrategy
{
    private final Object mutex = new Object();

    @Override
    public long waitFor(long sequence, Sequence cursorSequence, Sequence dependentSequence, SequenceBarrier barrier)
        throws AlertException, InterruptedException
    {
        long availableSequence;
        // 当前游标小于给定序号，也就是无可用事件
        if (cursorSequence.get() < sequence)
        {
            //也就是只有等待策略才会用锁，其余使用CAS，这就是前文提到的高效缘由
            synchronized (mutex)
            {
                // 当给定的序号大于生产者游标序号时，进行等待
                while (cursorSequence.get() < sequence)
                // 循环等待，在Sequencer中publish进行唤醒；等待消费时也会在循环中定时唤醒。
                {
                    barrier.checkAlert();
                    mutex.wait();
                }
            }
        }
        while ((availableSequence = dependentSequence.get()) < sequence)
        {
            barrier.checkAlert();
            ThreadHints.onSpinWait();
        }

        return availableSequence;
    }

WorkProcessor多线程处理事件（理解为集群消费）

WorkProcessor的原理和BatchEventProcessor相似，只是多了workSequence用来保存同组共用的处理序列。在更新workSequence时，涉及多线程操做，因此使用CAS进行更新。 

//WorkProcessor.java
    @Override
    public void run()
    {
        if (!running.compareAndSet(false, true))
        {
            throw new IllegalStateException("Thread is already running");
        }
        sequenceBarrier.clearAlert();

        notifyStart();

        boolean processedSequence = true;
        long cachedAvailableSequence = Long.MIN_VALUE;
        long nextSequence = sequence.get();
        T event = null;
        while (true)
        {
            try
            {
                // if previous sequence was processed - fetch the next sequence and set
                // that we have successfully processed the previous sequence
                // typically, this will be true
                // this prevents the sequence getting too far forward if an exception
                // is thrown from the WorkHandler
                // 表示nextSequence序号的处理状况（不区分正常或是异常处理）。只有处理过，才能申请下一个序号。
                if (processedSequence)
                {
                    processedSequence = false;
                    do
                    {
                        // 同组中多个消费线程有可能会争抢一个序号，使用CAS避免使用锁。
                        // 同一组使用一个workSequence，WorkProcessor不断申请下一个可用序号，对workSequence设置成功才会实际消费。
                        nextSequence = workSequence.get() + 1L;
                        sequence.set(nextSequence - 1L);
                    }
                    while (!workSequence.compareAndSet(nextSequence - 1L, nextSequence));
                }
                // 缓存的可用序号比要处理的序号大，才能进行处理
                if (cachedAvailableSequence >= nextSequence)
                {
                    event = ringBuffer.get(nextSequence);
                    workHandler.onEvent(event);
                    processedSequence = true;
                }
                // 更新缓存的可用序列。这个cachedAvailableSequence只用在WorkProcessor实例内，不一样实例的缓存多是不同
                else
                {
                    // 和单线程模式相似，返回的也是最大可用序号
                    cachedAvailableSequence = sequenceBarrier.waitFor(nextSequence);
                }
            }
            catch (final TimeoutException e)
            {
                notifyTimeout(sequence.get());
            }
            catch (final AlertException ex)
            {
                if (!running.get())
                {
                    break;
                }
            }
            catch (final Throwable ex)
            {
                // handle, mark as processed, unless the exception handler threw an exception
                exceptionHandler.handleEventException(ex, nextSequence, event);
                processedSequence = true;
            }
        }

        notifyShutdown();

        running.set(false);
    }

总结一波：

BatchEventProcessor主要用于处理单线程并行任务，同一消费者组的不一样消费者会接收相同的事件，并在全部事件处理完毕后进入下一消费者组进行处理（是否是相似JUC里的Phaser、CyclicBarrier或CountDownLatch呢）。WorkProcessor经过WorkerPool管理多个WorkProcessor，达到多线程处理事件的目的，同一消费者组的多个WorkProcessor不会处理同一个事件。经过选择不一样的WaitStragegy实现，能够控制消费者在没有可用事件处理时的等待策略。

应用场景总结

BatchEventProcessor

• 对Event的处理顺序有需求
• 单个Event的处理很是快（由于单线程）

WorkProcessor

• 对Event的处理顺序没有要求，虽然是顺序的消费，可是最终的消费前后取决于线程的调度，没有办法保证
• 单个Event的处理速度相对较慢（由于多线程）

具体的核心类分析，能够参考 https://github.com/Sonion/disroptor  里面有分析和注释，写个demo，打个断点，再看看核心类和方法，Disruptor 源码仍是简单的，主要是环形队列，循环写入，不用GC回收，还有一些缓存行优化，无锁等处理是值得学习和思考的。

参考资料：

一、参考demo能够看这里

http://www.javashuo.com/article/p-acgvopbo-dv.html

二、简单资料

https://blog.csdn.net/changong28/article/details/43637679

http://brokendreams.iteye.com/category/349033