Disruptor是一个高吞吐量的异步处理框架，LMAX号称用它可以1秒钟处理600万订单，从一个简单的例子来分析Disruptor，下面的代码是基于2.10.4版本，不同的版本API可能会有些变化，代码仅供参考。
private static void testDisruptor() {
RingBuffer<MyEvent> ringBuffer = new RingBuffer<MyEvent>(
new EventFactory<MyEvent>() {
@Override
public MyEvent newInstance() {
return new MyEvent();
}
}, new SingleThreadedClaimStrategy(RING_SIZE),
new BlockingWaitStrategy());
// SequenceBarrier
SequenceBarrier barrier1 = ringBuffer.newBarrier();
// 注册一个EventProcessor
BatchEventProcessor<MyEvent> processor1 = new BatchEventProcessor<MyEvent>(
ringBuffer, barrier1, new EventHandler<MyEvent>() {
@Override
public void onEvent(MyEvent event, long sequence,
boolean endOfBatch) throws Exception {
System.out.println(event.s + "A:" + event.i
+ ":Thread.id-"
+ Thread.currentThread().getId());
}
});
//
ringBuffer.setGatingSequences(Util.getSequencesFor(processor1));
publishEvent(ringBuffer);
EXECUTOR.execute(processor1);
}
private static void publishEvent(RingBuffer<MyEvent> ringBuffer) {
final EventPublisher<MyEvent> eventPublisher = new EventPublisher<MyEvent>(
ringBuffer);
EXECUTOR_0.execute(new Runnable() {
@Override
public void run() {
for (long i = 0; i < Long.MAX_VALUE; i++) {
final long number = i;
eventPublisher.publishEvent(new EventTranslator<MyEvent>() {
@Override
public void translateTo(MyEvent event, long sequence) {
event.s = "a" + number;
event.i = "b" + number;
}
});
}
}
});
}public final class RingBuffer<T> extends Sequencer
{
...
}
public class Sequencer
{
/** Set to -1 as sequence starting point */
public static final long INITIAL_CURSOR_VALUE = -1L;
private final Sequence cursor = new Sequence(Sequencer.INITIAL_CURSOR_VALUE);
private Sequence[] gatingSequences;
private final ClaimStrategy claimStrategy;
private final WaitStrategy waitStrategy;
/**
* Construct a Sequencer with the selected strategies.
*
* @param claimStrategy for those claiming sequences.
* @param waitStrategy for those waiting on sequences.
*/
public Sequencer(final ClaimStrategy claimStrategy, final WaitStrategy waitStrategy)
{
this.claimStrategy = claimStrategy;
this.waitStrategy = waitStrategy;
}
/**
* Claim the next event in sequence for publishing.
*
* @return the claimed sequence value
*/
public long next()
{
if (null == gatingSequences)
{
throw new NullPointerException("gatingSequences must be set before claiming sequences");
}
return claimStrategy.incrementAndGet(gatingSequences);
}
...
private void publish(final long sequence, final int batchSize)
{
claimStrategy.serialisePublishing(sequence, cursor, batchSize);
waitStrategy.signalAllWhenBlocking();
}
}public final class SingleThreadedClaimStrategy
implements ClaimStrategy
{
private final int bufferSize;
private final PaddedLong minGatingSequence = new PaddedLong(Sequencer.INITIAL_CURSOR_VALUE);
private final PaddedLong claimSequence = new PaddedLong(Sequencer.INITIAL_CURSOR_VALUE);
...
@Override
public long incrementAndGet(final Sequence[] dependentSequences)
{
long nextSequence = claimSequence.get() + 1L;
claimSequence.set(nextSequence);
waitForFreeSlotAt(nextSequence, dependentSequences);
return nextSequence;
}
@Override
public long incrementAndGet(final int delta, final Sequence[] dependentSequences)
{
long nextSequence = claimSequence.get() + delta;
claimSequence.set(nextSequence);
waitForFreeSlotAt(nextSequence, dependentSequences);
return nextSequence;
}
@Override
public void serialisePublishing(final long sequence, final Sequence cursor, final int batchSize)
{
cursor.set(sequence);
}
...
private void waitForFreeSlotAt(final long sequence, final Sequence[] dependentSequences)
{
final long wrapPoint = sequence - bufferSize;
if (wrapPoint > minGatingSequence.get())
{
long minSequence;
while (wrapPoint > (minSequence = getMinimumSequence(dependentSequences)))
{
LockSupport.parkNanos(1L);
}
minGatingSequence.set(minSequence);
}
}
}在单写策略SingleThreadedClaimStrategy代码中看到claimSequence变量是一个PaddedLong类型，来看看这是个什么东东：
public final class PaddedLong extends MutableLong
{
public volatile long p1, p2, p3, p4, p5, p6 = 7L;
...
}
public class MutableLong
{
private long value = 0L;
...
}看到一段奇怪的代码，PaddedLong中定义了p1-p6六个看起来没什么用处的的long类型变量，为什么要定义这些不会被使用的变量呢？经过对谷歌度娘的一番骚扰后终于明白了原委，这是跟CPU高速缓存有关的，CPU缓存是以缓存行为单位的，缓存行的大小通常是64个字节，CPU在加载数据到缓存的时候会把地址相邻的变量都加载到缓存行把缓存行填满，这种方式会存在一个问题，当把总大小64字节的多个变量都加载到缓存行之后，只要其中一个变量发生变化，那么会导致整个缓存行失效，从而导致整个缓存行的数据都被刷出，这种现象有个专门的术语描述叫false sharing（伪共享），关于伪共享大神有比较详细的阐述 False Sharing。定义这6个long类型的变量的目的就是为了填充缓存行，让value字段单独占用一个缓存行消除伪共享（这里不得不跪拜大神对性能极致的追求，看来写出高质量的代码对计算机体系架构也是必须要了解的）。
对于claimSequence变量在多线程策略中是Sequence类型的，它也添加了缓存行填充处理，多写策略需要保证线程安全，它使用UnSafe工具调用CAS操作确保修改数据时线程安全。
public abstract class AbstractMultithreadedClaimStrategy implements ClaimStrategy
{
private final int bufferSize;
private final Sequence claimSequence = new Sequence(Sequencer.INITIAL_CURSOR_VALUE);
...
}public class Sequence
{
private static final Unsafe unsafe;
private static final long valueOffset;
static
{
unsafe = Util.getUnsafe();
final int base = unsafe.arrayBaseOffset(long[].class);
final int scale = unsafe.arrayIndexScale(long[].class);
valueOffset = base + (scale * 7);
}
private final long[] paddedValue = new long[15];
public Sequence()
{
setOrdered(-1);
}
public Sequence(final long initialValue)
{
setOrdered(initialValue);
}
public long get()
{
return unsafe.getLongVolatile(paddedValue, valueOffset);
}
public void set(final long value)
{
unsafe.putOrderedLong(paddedValue, valueOffset, value);
}
private void setOrdered(final long value)
{
unsafe.putOrderedLong(paddedValue, valueOffset, value);
}
public boolean compareAndSet(final long expectedValue, final long newValue)
{
return unsafe.compareAndSwapLong(paddedValue, valueOffset, expectedValue, newValue);
}
public String toString()
{
return Long.toString(get());
}
public long incrementAndGet()
{
return addAndGet(1L);
}
public long addAndGet(final long increment)
{
long currentValue;
long newValue;
do
{
currentValue = get();
newValue = currentValue + increment;
}
while (!compareAndSet(currentValue, newValue));
return newValue;
}
}上面分析的时候说到RingBuffer的读指针时在消费者中维护的，来看看消费者代码：
public final class BatchEventProcessor<T>
implements EventProcessor
{
private final AtomicBoolean running = new AtomicBoolean(false);
private ExceptionHandler exceptionHandler = new FatalExceptionHandler();
private final RingBuffer<T> ringBuffer;
private final SequenceBarrier sequenceBarrier;
private final EventHandler<T> eventHandler;
private final Sequence sequence = new Sequence(Sequencer.INITIAL_CURSOR_VALUE);
...
/**
* It is ok to have another thread rerun this method after a halt().
*/
@Override
public 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;
while (true)
{
try
{
final long availableSequence = sequenceBarrier.waitFor(nextSequence);
while (nextSequence <= availableSequence)
{
event = ringBuffer.get(nextSequence);
eventHandler.onEvent(event, nextSequence, nextSequence == availableSequence);
nextSequence++;
}
sequence.set(nextSequence - 1L);
}
catch (final AlertException ex)
{
if (!running.get())
{
break;
}
}
catch (final Throwable ex)
{
exceptionHandler.handleEventException(ex, nextSequence, event);
sequence.set(nextSequence);
nextSequence++;
}
}
notifyShutdown();
running.set(false);
}
...
}在RingBuffer中还有个细节值得注意，队列的大小必须是2的次幂，这样做的目的是在计算位置对队列大小求模时可以直接用位操作，位操作显然比除法要快（抠的就是细节呀）：
public RingBuffer(final EventFactory<T> eventFactory,
final ClaimStrategy claimStrategy,
final WaitStrategy waitStrategy)
{
super(claimStrategy, waitStrategy);
if (Integer.bitCount(claimStrategy.getBufferSize()) != 1)
{
throw new IllegalArgumentException("bufferSize must be a power of 2");
}
indexMask = claimStrategy.getBufferSize() - 1;
entries = new Object[claimStrategy.getBufferSize()];
fill(eventFactory);
}
public T get(final long sequence)
{
return (T)entries[(int)sequence & indexMask];
}1、RingBuffer基于数组，数组元素可重用不会被删除，与链表队列相比它对象创建少对GC友好，而且数组访问比链表快
2、减少队列的竞争点，只有在多线程生产者策略下才会对写入位置发生争用，读指针的维护转移到消费者线程，如果生产者是单线程策略那么整个RingBuffer都是无竞争的。而普通的队列会有头、尾、队列长度多个竞争点
3、整个RingBuffer在正常情况下访问都没有锁的痕迹，使用CAS操作代替锁，生产者消费者读写速度不匹配导致需要等待的情况下除外
4、采用缓存填充行消除缓存伪共享
5、数组大小强制2的次幂，通过位运算来求模提升计算速度
143
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
