学习Disruptor时的一些联想和总结

一、前言

  前两天整log4j2的时候不是碰到Disruptor了嘛，想着能不能从这个吹爆了的并发框架里汲取些性能优化的思路呢。稍微学习下源码，还真是有收获的。

对Disruptor感兴趣的小伙伴可以看看哈希大佬的博客，对于Disruptor有系列文章，算是网上比较细的https://blog.csdn.net/zhxdick...

二、RingBuffer

  大致看了下，好像所有的点都和RingBuffer有关，就将标题写成RingBuffer。

1. Disruptor在初始化的时候创建指定大小的RingBuffer，创建之后大小恒定，不会自动扩容，避免了频繁扩容的性能损耗；【可以联想到List、Map、StringBuilder、StringBuffer些自动扩容的骚玩意儿】
    
2. RingBuffer中存放数据的核心是entries的数组变量，RingBuffer初始化的时候会进行数据预分配【是不是类似一些池化的东西】，将数组填满；【数据内容为自定义的event对象】。这段逻辑在RingBuffer的父类RingBufferFields实现中可以看到：

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

3. RingBuffer相比较其他环形数据结构，基于数组实现【可以充分利用CPU cache line，高性能】，没有尾指针，只有一个next指针，指向下一个可用位置。
    
4. RingBuffer循环写的核心思想是，使用sequence的下标和bufferSize进行取模运算，实际使用的位运算【联想到HashMap的数组定位】，在二进制环境下，位运算比mod运算性能高很多。
    
5. RingBuffer不会主动清除已经消费过的对象信息，只会覆盖先前的数据，而覆盖操作其实是自定义event对象属性的覆盖。这里实现了对象重用，降低了GC压力。
   对象重用在某些地方对性能提升简直就是起飞模式，特别对于那些频繁初始化的重类比如xstream，或者可能会涉及类加载这种耗时操作的，尽可能使用单例模式或者对象池进行操作。
    
6. Disruptor充分利用了CPU cache line的强大性能，为了解决伪共享的问题，在频繁使用的Sequence类和RingBuffer类中，可以看到很多用来填充对齐的long变量；Sequence在处理的时候在左右分别设置7位padding long【缓存填充数据】保证独占缓存行；

class LhsPadding
{
    protected long p1, p2, p3, p4, p5, p6, p7;
}

class Value extends LhsPadding
{
    protected volatile long value;
}

class RhsPadding extends Value
{
    protected long p9, p10, p11, p12, p13, p14, p15;
}

同样的操作在RingBuffer中：

abstract class RingBufferPad
{
    protected long p1, p2, p3, p4, p5, p6, p7;
}

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

public final class RingBuffer<E> extends RingBufferFields<E> implements Cursored, EventSequencer<E>, EventSink<E>
{
    public static final long INITIAL_CURSOR_VALUE = Sequence.INITIAL_VALUE;
    protected long p1, p2, p3, p4, p5, p6, p7;
    ....
}

7. 还有就是Disruptor的大思想，无锁化。Disruptor中，除了WaitStrategy那块涉及到ReentrantLock外，基本就没有其他锁的操作，要么就是CAS。在多线程环境下，线程数越多，线程程竞争越激烈，锁的开销越大。这里甚至可以联想到一些无锁串行化的应用实现，比如redis，netty。
   还有类似的其他无锁的框架：java.util.concurrent.atomic包、Amino框架。

结尾

  也没啥说的了，如果对各位小伙伴有些些启发的话，就关注我吧➕。