【Java多线程】Disruptor源码分析（三十四）

Disruptor类图

　　

Disruptor执行过程

　　

Disruptor源码分析

// 环形缓冲区
private final RingBuffer<T> ringBuffer;
// 实现者
private final Executor executor;
// 消费仓库
private final ConsumerRepository<T> consumerRepository = new ConsumerRepository<>();
// 启动标识，原子boolean类，Disruptor只能启动一次
private final AtomicBoolean started = new AtomicBoolean(false);
// 异常处理器
private ExceptionHandler<? super T> exceptionHandler = new ExceptionHandlerWrapper<>();




// 主要有3个未过时的构造方法
public Disruptor(final EventFactory<T> eventFactory, final int ringBufferSize, final ThreadFactory threadFactory)
{
    this(RingBuffer.createMultiProducer(eventFactory, ringBufferSize), new BasicExecutor(threadFactory));
}


// eventFactory 事件工厂
// ringBufferSize 环形缓冲区大小
// producerType 生产者类型
// waitStrategy 阻塞策略
public Disruptor(
        final EventFactory<T> eventFactory,
        final int ringBufferSize,
        final ThreadFactory threadFactory,
        final ProducerType producerType,
        final WaitStrategy waitStrategy)
{
    this(
        RingBuffer.create(producerType, eventFactory, ringBufferSize, waitStrategy),
        new BasicExecutor(threadFactory));
}


private Disruptor(final RingBuffer<T> ringBuffer, final Executor executor)
{
    this.ringBuffer = ringBuffer;
    this.executor = executor;
}





// 创建环形缓冲区
public static <E> RingBuffer<E> create(
    ProducerType producerType,
    EventFactory<E> factory,
    int bufferSize,
    WaitStrategy waitStrategy)
{
    // 选择对应生产者类型的环形缓冲区创建
    switch (producerType)
    {
        case SINGLE:
            // 单生产者类型
            return createSingleProducer(factory, bufferSize, waitStrategy);
        case MULTI:
            return createMultiProducer(factory, bufferSize, waitStrategy);
        default:
            throw new IllegalStateException(producerType.toString());
    }
}


// 创建单生产者类型的环形缓冲区
public static <E> RingBuffer<E> createSingleProducer(
    EventFactory<E> factory,
    int bufferSize,
    WaitStrategy waitStrategy)
{
    // 
    SingleProducerSequencer sequencer = new SingleProducerSequencer(bufferSize, waitStrategy);

    return new RingBuffer<E>(factory, sequencer);
}

// 构造方法 SingleProducerSequencer
public SingleProducerSequencer(int bufferSize, WaitStrategy waitStrategy)
{
    super(bufferSize, waitStrategy);
}


// 构造方法 RingBuffer
RingBuffer(
    EventFactory<E> eventFactory,
    Sequencer sequencer)
{
    super(eventFactory, sequencer);
}




// RingBuffer 的父中存在的静态块
bstract class RingBufferFields<E> extends RingBufferPad
{
    // 缓存填充数量，即空白数组长度（看静态代码块理解）
    private static final int BUFFER_PAD;
    // 真实存数据数组的内存偏移量（看静态代码块理解）
    private static final long REF_ARRAY_BASE;
    // 引用数据类型左移数（看静态代码块理解）
    private static final int REF_ELEMENT_SHIFT;
    private static final Unsafe UNSAFE = Util.getUnsafe();

    static
    {
        // UNSAFE.arrayIndexScale 是获取一个数组在内存中的scale，
        // 也就是每个数组元素在内存中的元素的内存偏移量
        // 因为我们的event是任意一个对象，所以在这里用一个Object的数组class来求scale
        final int scale = UNSAFE.arrayIndexScale(Object[].class);
        // 不同的JVM设置，它的指针大小是不一样的
        if (4 == scale)
        {
            // 计算内存偏移量的常量，数量 << REF_ELEMENT_SHIFT
            // 例如：int[2]，第一个元素的偏移量就是 16 + 0 << 2，第二个 16 + 1 << 2
            REF_ELEMENT_SHIFT = 2;
        }
        else if (8 == scale)
        {
            // 例如：long[2]，第一个元素的偏移量就是 16 + 0 << 3，第二个 16 + 1 << 3
            REF_ELEMENT_SHIFT = 3;
        }
        else
        {
            throw new IllegalStateException("Unknown pointer size");
        }
        // 缓存行是64个字节
        // 由于数据是保存在数组中的，所以要将数据与其他变量隔开，让数组真实数据与其他变量不在同一个缓存行中
        // 即：A变量 + 缓存隔离带(128个字节) + 数组真实数据 + 缓存隔离带(128个字节) + B变量
        // 缓存隔离带使用空数组来代替
        // 即：A变量 + 空白数组(128个字节) + 数组真实数据 + 空白数组(128个字节) + A变量
        // 计算：128 / 对象在内存的大小 scale = BUFFER_PAD （即是空白数组的长度）
        BUFFER_PAD = 128 / scale;
        // 获取数组在内存中的偏移量，也就是第一个真实数据元素的内存偏移量
        // 由于数组 是分三部分，空白数组(128个字节) + 数组真实数据 + 空白数组(128个字节) 
        // 那么数组真实数据起始偏移量就是：UNSAFE.arrayBaseOffset(Object[].class) + 空白数组(128个字节)
        // 空白数据的个数就是 BUFFER_PAD，它向左移 REF_ELEMENT_SHIFT ，得到的就是空白数组的内存偏移量
        // REF_ARRAY_BASE = （数组对象头 + 空白数组(128个字节)）
        REF_ARRAY_BASE = UNSAFE.arrayBaseOffset(Object[].class) + (BUFFER_PAD << REF_ELEMENT_SHIFT);

    }

    private final long indexMask; // 索引标识
    private final Object[] entries;//申明一个对象数组
    protected final int bufferSize;
    protected final Sequencer sequencer;

    RingBufferFields(
        EventFactory<E> eventFactory,
        Sequencer sequencer)
    {
        this.sequencer = sequencer;
        this.bufferSize = sequencer.getBufferSize();

        if (bufferSize < 1)
        {
            throw new IllegalArgumentException("bufferSize must not be less than 1");
        }
        if (Integer.bitCount(bufferSize) != 1)
        {
            throw new IllegalArgumentException("bufferSize must be a power of 2");
        }
        // 索引标识
        this.indexMask = bufferSize - 1; //indexMask 就是数组的最大下标
        // 有上静态代码块可知，整个数组是 空白数组(128个字节) + 数组真实数据 + 空白数组(128个字节)
        // 数据长度就是：BUFFER_PAD + sequencer.getBufferSize() + BUFFER_PAD
        this.entries = new Object[sequencer.getBufferSize() + 2 * BUFFER_PAD];
        // 给正式数据数组，初始化值，使用eventFactory
        fill(eventFactory);
    }
}

// 获取sequence下标的元素
protected final E elementAt(long sequence)
{
    // 构造方法初始化时：indexMask = bufferSize - 1;
    // 整个数组是 空白数组(128个字节) + 数组真实数据 + 空白数组(128个字节)
    // REF_ARRAY_BASE = （数组对象头 + 空白数组(128个字节)）
    // 根据内存偏移量取获取对应数组元素
    return (E) UNSAFE.getObject(entries, REF_ARRAY_BASE + ((sequence & indexMask) << REF_ELEMENT_SHIFT));
}

// 填入生产事件
private void fill(EventFactory<E> eventFactory)
{
    for (int i = 0; i < bufferSize; i++)
    {
        entries[BUFFER_PAD + i] = eventFactory.newInstance();
    }
}


// 构造方法 BasicExecutor
public BasicExecutor(ThreadFactory factory)
{
    this.factory = factory;
}



// Disruptor 类中 handleEventsWith()
public final EventHandlerGroup<T> handleEventsWith(final EventHandler<? super T>... handlers)
{
    return createEventProcessors(new Sequence[0], handlers);
}


// Disruptor 类中 createEventProcessors()
EventHandlerGroup<T> createEventProcessors(
        final Sequence[] barrierSequences,
        final EventHandler<? super T>[] eventHandlers)
{
    // 检查没有启动
    checkNotStarted();

    // 创建处理序列器组
    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);
        // 将sequence添加到组中
        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)
    {
        // 给 ringBuffer 添加 进程中的 栅栏序列信息
        ringBuffer.addGatingSequences(processorSequences);
        for (final Sequence barrierSequence : barrierSequences)
        {
            // 移除 barrierSequence
            ringBuffer.removeGatingSequence(barrierSequence);
        }
        consumerRepository.unMarkEventProcessorsAsEndOfChain(barrierSequences);
    }
}



// 启动RingBuffer
public RingBuffer<T> start()
{
    // 启动，检查是否只启动一次
    checkOnlyStartedOnce();
    // 遍历消费者仓库
    for (final ConsumerInfo consumerInfo : consumerRepository)
    {
        // 消费
        consumerInfo.start(executor);
    }

    return ringBuffer;
}



// 启动，并检查是否只启动一次
private void checkOnlyStartedOnce()
{
    if (!started.compareAndSet(false, true))
    {
        throw new IllegalStateException("Disruptor.start() must only be called once.");
    }
}


// EventProcessorInfo 类中的 start()
@Override
public void start(final Executor executor)
{
    // 执行事件处理器
    executor.execute(eventprocessor);
}




// 执行事件处理器
@Override
public void execute(Runnable command)
{
    // 使用线程工厂创建了一个线程
    final Thread thread = factory.newThread(command);
    if (null == thread)
    {
        throw new RuntimeException("Failed to create thread to run: " + command);
    }

    // 启动线程
    thread.start();

    // 添加到线程队列中
    threads.add(thread);
}


// 获取 环形缓冲区
public RingBuffer<T> getRingBuffer()
{
    return ringBuffer;
}


// 获取序列号为 sequence 的元素
public E get(long sequence)
{
    // 获取序列号为 sequence 的元素
    return elementAt(sequence);
}



// RingBuffer 类中的 next()
public long next()
{
    return sequencer.next();
}


// SingleProducerSequencer 类中的 next()
public long next()
{
    return next(1);
}


// 获取下一个Sequencer 序列号
public long next(int n)
{
    if (n < 1)
    {
        throw new IllegalArgumentException("n must be > 0");
    }

    // 取出 Sequencer 记录的 上一次返回序列号nextValue
    long nextValue = this.nextValue;
    // 根据要取出数量n，计算下标nextSequence值
    long nextSequence = nextValue + n;
    // 超过缓存大小的差值
    long wrapPoint = nextSequence - bufferSize;
    // 缓存值大门值
    long cachedGatingSequence = this.cachedValue;
    // 判断超过缓存大小的差值 是否大于 大门值 或者 大门值 > nextValue
    if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue)
    {
        // CAS设置了游标的值
        // 加入了StoreLoad屏障，保证写入都，其他线程可见
        cursor.setVolatile(nextValue);  // StoreLoad fence
        // 最小顺序值
        long minSequence;
        // 判断超过缓存大小的差值 是否大于 最小的序号
        while (wrapPoint > (minSequence = Util.getMinimumSequence(gatingSequences, nextValue)))
        {
            // 休眠1纳秒
            LockSupport.parkNanos(1L); // TODO: Use waitStrategy to spin?
        }
        //  最小的序号 赋值给 缓存值
        this.cachedValue = minSequence;
    }
    // 记录返回序列号
    this.nextValue = nextSequence;

    return nextSequence;
}




// 发布
public void publish(long sequence)
{
    // 设置游标序号
    cursor.set(sequence);
    // 通知所有阻塞线程
    waitStrategy.signalAllWhenBlocking();
}



// 运行
public void run()
{
    // 判断线程运行状态
    if (!running.compareAndSet(IDLE, RUNNING))
    {
        if (running.get() == RUNNING)
        {
            throw new IllegalStateException("Thread is already running");
        }
    }
    // 序列号屏障情况告警
    sequenceBarrier.clearAlert();

    // 通知开启
    notifyStart();

    try
    {
        // 判断线程是否处于暂停状态
        if (running.get() == HALTED)
        {
            return;
        }

        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);
                    // 调用onEvent() 处理事件元素
                    eventHandler.onEvent(event, nextSequence, nextSequence == availableSequence);
                    nextSequence++;
                }
                // 直到 下一个序列号 > 获取可用的序列号
                // 记录 序列号到达的位置
                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++;
            }
        }
    }
    finally
    {   
        // 通知关闭
        notifyShutdown();
        // 设置线程状态
        running.set(IDLE);
    }
}




public void clearAlert()
{
    alerted = false;
}




// ProcessingSequenceBarrier 中的waitFor()
public long waitFor(final long sequence)
    throws AlertException, InterruptedException, TimeoutException
{
    // 检查告警，如果告警直接报异常
    // disruptor调用停止方法时，alert为true，则会告警
    checkAlert();

    // 获取可用的序列号
    long availableSequence = waitStrategy.waitFor(sequence, cursorSequence, dependentSequence, this);

    // 判断可用序列号 是否小于 请求序列号
    if (availableSequence < sequence)
    {
        return availableSequence;
    }

    // 返回最高可用的序列号，即是 availableSequence
    return sequencer.getHighestPublishedSequence(sequence, availableSequence);
}

// BlockingWaitStrategy 中的 waitFor()
public 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)
            {
                // 检查告警, disruptor调用停止方法时会告警
                barrier.checkAlert();
                // 线程条件等待
                processorNotifyCondition.await();
            }
        }
        finally
        {
            // 解锁
            lock.unlock();
        }
    }

    // 从依赖的序列器中获取 可用的序列号 
    while ((availableSequence = dependentSequence.get()) < sequence)
    {

        barrier.checkAlert();
        ThreadHints.onSpinWait();
    }

    return availableSequence;
}