Disruptor源码（一）RingBuffer底层结构 & 构建过程

RingBuffer源码核心

• 底层用数组Object[] entries存储元素，不会扩容，满了之后从数组头开始填充，所谓环形数组；
• 内存预加载，在RingBuffer初始化的时候，就用空Event对象填充entries，初始化后不再新建Event对象 ，消除了不断new对象带来的开销，只对entries中的Event对象做update操作；

RingBufferFields

• 其作为RingBuffer的父类，维护了RingBuffer中最核心的数据结构；
• 组合了一个Sequencer，由构造器传入；
• RingBuffer中用于存放元素的数组是维护在它里面的，private final Object[] entries;
• RingBuffer中的bufferSize是维护在它里面的，是由Sequencer赋值的，protected final int bufferSize;

Sequencer

• 在初始化其子类时（MultiProducerSequencer），需要传入bufferSize，RingBuffer的bufferSize也是由Sequencer的子类初始化的，Sequencer的子类是知道RingBuffer的bufferSize的；
• 那么1个Sequencer和1个RingBuffer起码有个对应关系；
• RingBufferFields组合了Sequencer，Sequencer知道RingBuffer的bufferSize；

RingBuffer的构造过程

0）客户端代码

RingBuffer<Order> ringBuffer =
                RingBuffer.create(
                        ProducerType.MULTI,
                        new EventFactory<Order>() {
                            public Order newInstance() {
                                return new Order();
                            }
                        },
                        1024 * 1024,
                        new YieldingWaitStrategy());

1）RingBuffer#create - 根据producerType决定创建哪一种Sequencer

• producerType：决定了创建Sequencer的具体类型，具体的Sequencer用于初始化RingBuffer；
• factory：用于初始化RingBuffer；
• bufferSize：创建具体Sequencer用；
• waitStrategy：创建具体Sequencer用；

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());
    }
}

2）RingBuffer#createMultiProducer - 创建具体类型的Sequencer，并用具体Sequencer创建RingBuffer

• factory：用于初始化RingBuffer；
• bufferSize：创建具体Sequencer用；
• waitStrategy：创建具体Sequencer用；

public static <E> RingBuffer<E> createMultiProducer(EventFactory<E> factory,
                                                    int             bufferSize,
                                                    WaitStrategy    waitStrategy)
{
    MultiProducerSequencer sequencer = new MultiProducerSequencer(bufferSize, waitStrategy);

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

3）RingBuffer#RingBuffer - 调用父类RingBufferFields的构造方法

RingBuffer(EventFactory<E> eventFactory,
               Sequencer       sequencer)
{
    super(eventFactory, sequencer);
}

4）RingBufferFields#RingBufferFields - 初始化RingBuffer中的数组

• 用sequencer初始化sequencer，bufferSize，indexMask等成员变量；
• 开辟了entries的大小；
• 向entries中填充空Event，用EventFactory；

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;
    this.entries   = new Object[sequencer.getBufferSize() + 2 * BUFFER_PAD];
    fill(eventFactory);
}

5）RingBufferFields#fill - 实现内存预加载的代码

• eventFactory：调用RingBuffer#create时传入的EventFactory类；

注意：初始化对entries的填充，entries的两头各空了BUFFER_PAD个空间；BUFFER_PAD的大小跟计算出来的scale有关，scale表示Object[]数组的比例因子；BUFFER_PAD等于32或16

private void fill(EventFactory<E> eventFactory)
{
    for (int i = 0; i < bufferSize; i++)
    {
        entries[BUFFER_PAD + i] = eventFactory.newInstance();
    }
}