c ringbuffer 源码_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

要明确一件事情，RingBuffer和Sequencer和是有组合关系的，Sequencer向RingBuffer提供服务，不同的子类提供不同的服务；

Sequencer作为RingBuffer服务者，要知道RingBuffer的相关信息，这些信息包括：bufferSize，waitStrategy，cursor，gatingSequences；

在初始化其子类时(MultiProducerSequencer)，需要传入bufferSize，RingBuffer的bufferSize也是由Sequencer的子类初始化的，Sequencer的子类是知道RingBuffer的bufferSize的，Sequencer有点像RingBuffer的管家，关它的初始化，取，存等；

那么1个Sequencer和1个RingBuffer起码有个对应关系；

RingBufferFields组合了Sequencer，两者之间的关系是在抽象层建立的；

AbstractSequencer

这是实现Sequencer接口的抽象类，Sequencer作为RingBuffer的服务提供者，RingBuffer中的相关信息是维护在AbstractSequencer中的，包括：bufferSize，waitStrategy，cursor，gatingSequences；

SingleProducerSequencer

作为Sequencer的具体实现，向RingBuffer提供服务单生产者模式下的服务；

其在服务的过程中，RingBuffer中的相关消息它是可以知道的，在其父类AbstractSequencer中维护；

RingBuffer的构造过程

0)客户端代码

RingBuffer ringBuffer =

RingBuffer.create(

ProducerType.MULTI,

new EventFactory() {

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 RingBuffer create(ProducerType producerType,

EventFactory 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 RingBuffer createMultiProducer(EventFactory factory,

int bufferSize,

WaitStrategy waitStrategy)

{

MultiProducerSequencer sequencer = new MultiProducerSequencer(bufferSize, waitStrategy);

return new RingBuffer(factory, sequencer);

}

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

RingBuffer(EventFactory eventFactory,

Sequencer sequencer)

{

super(eventFactory, sequencer);

}

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

用sequencer初始化sequencer，bufferSize，indexMask等成员变量；

开辟了entries的大小；

向entries中填充空Event，用EventFactory；

RingBufferFields(EventFactory 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 eventFactory)

{

for (int i = 0; i < bufferSize; i++)

{

entries[BUFFER_PAD + i] = eventFactory.newInstance();

}

}