一、前言

  前两天整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();    }}
  1. RingBuffer相比拟其余环形数据结构，基于数组实现【能够充分利用CPU cache line，高性能】，没有尾指针，只有一个next指针，指向下一个可用地位。
     
  2. RingBuffer循环写的核心思想是，应用sequence的下标和bufferSize进行取模运算，理论应用的位运算【联想到HashMap的数组定位】，在二进制环境下，位运算比mod运算性能高很多。
     
  3. RingBuffer不会被动革除曾经生产过的对象信息，只会笼罩先前的数据，而笼罩操作其实是自定义event对象属性的笼罩。这里实现了对象重用，升高了GC压力。
    对象重用在某些中央对性能晋升几乎就是腾飞模式，特地对于那些频繁初始化的重类比方xstream，或者可能会波及类加载这种耗时操作的，尽可能应用单例模式或者对象池进行操作。
     
  4. 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;    ....}
  1. 还有就是Disruptor的大思维，无锁化。Disruptor中，除了WaitStrategy那块波及到ReentrantLock外，根本就没有其余锁的操作，要么就是CAS。在多线程环境下，线程数越多，线程程竞争越强烈，锁的开销越大。这里甚至能够联想到一些无锁串行化的利用实现，比方redis，netty。
    还有相似的其余无锁的框架：java.util.concurrent.atomic包、Amino框架。

结尾

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