1 Disruptor學習

在上一篇文章中，筆者提到了log4j2中的異步logger。通過測試數據來看，在使用異步logger后，打印日志的時間明顯縮短，系統響應時間得到了巨大的提升。

那么，disruptor究竟是什么，為什么它可以提升系統的性能？

1.1 Disruptor簡介

Disruptor是一個開源框架，研發的初衷是為了解決高并發下列隊鎖的問題，最早由LMAX（一種新型零售金融交易平臺）提出并使用，能夠在無鎖的情況下實現隊列的并發操作，并號稱能夠在一個線程里每秒處理6百萬筆訂單（我是不相信）。

隊列的特性：先進先出（FIFO）--先進入隊列的元素先出隊列（可以理解為我們生活中的排隊情況，早辦完，早滾蛋）。生產者(Producer)往隊列里發布(publish)事件，消費者(Consumer)獲得通知，消費事件；如果隊列中沒有事件時，消費者堵塞，直到生產者發布了新事件。

說到隊列，那就不得不提到Java中的concurrent包，其主要實現包括ArrayBlockingQueue、LinkedBlockingQueue、ConcurrentLinkedQueue、LinkedTransferQueue。下面，簡單介紹下：

ArrayBlockingQueue：基于數組形式的隊列，通過加鎖的方式，來保證多線程情況下數據的安全；

LinkedBlockingQueue：基于鏈表形式的隊列，也通過加鎖的方式，來保證多線程情況下數據的安全；

ConcurrentLinkedQueue：基于鏈表形式的隊列，通過compare and swap(簡稱CAS)協議的方式，
來保證多線程情況下數據的安全，不加鎖，主要使用了Java中的sun.misc.Unsafe類來實現；

LinkedTransferQueue：同上；

通過查看以上4個類的源碼，可以發現：

（1）使用CAS協議實現隊列的類，都是無界的，無法保證隊列的長度，理論上來說可以是無限擴展，那么如果生產者生產過快，消費者還沒來得及消費，最終可能會導致內存溢出，影響系統穩定；

（2）而使用加鎖實現隊列的類，雖然是有界的（可以設置隊列的大小），但是有鎖的存在，性能上有了很大的影響，線程由于鎖的競爭被掛起，直到鎖的釋放，才能恢復。此外，由于偽共享的存在，也會影響性能

而Disruptor解決了以上的問題，實現了無鎖有界隊列操作。主要是使用了環形數組（ringbuffer）、CAS、緩存行填充、解決偽共享等技術，接下來我們一一講解；

1.2 Disruptor結構

在講解disruptor所使用的相關技術之前，我覺得有必要簡單的介紹下的Disruptor結構！

前面介紹了，Disruptor是一個開源的框架，可以在無鎖的情況下對隊列進行操作，那么這個隊列的設計就是Disruptor的核心所在；

在Disruptor中，采用了RingBuffer來作為隊列的數據結構，RingBuffer就是一個環形的數組，既然是數組，我們便可對其設置大小。在這個ringBuffer中，除了數組之外，還有一個序列號，是用來指向數組中的下一個可用元素，供生產者使用或者消費者使用，也就是生產者可以生產的地方，或者消費者可以消費的地方。（序列號和數組索引是兩個概念，別搞錯了）

Disruptor使用數組作為隊列的另一個好處，就是可以快速定位到所需元素，通常使用取摸運算（序列號%數組大小=所需元素角標），但在Disruptor中使用的是位運算（具體實現：UNSAFE.getObject(entries, REF_ARRAY_BASE + ((sequence & indexMask) << REF_ELEMENT_SHIFT))），效率更高，定位更快；此外，在Disruptor中數組內的元素并不會被刪除，而是新數據來覆蓋原有數據；

1.3 Disruptor代碼簡單實現

我們就以一個簡單例子來實現Disruptor：生產者傳遞一個long類型變量給消費者，消費者將這個變量打印出來。

單生產者，單消費者模型：

（1）向ringbuffer中插入的事件元素：就是在對象中放了一個long變量

public class LongEvent {

    private long value;

    public long getValue() {
        return value;
    }

    public void setValue(long value) {
        this.value = value;
    }
}

（2）事件生產工廠：生產事件存入ringbuffer中

public class LongEventFactory implements EventFactory<LongEvent> {

    public LongEvent newInstance() {
        return new LongEvent();
    }
}

（3）事件處理器，也就是消費者，就是將事件的值打印出來

public class LongEventHandler implements EventHandler<LongEvent> {

    public void onEvent(LongEvent event, long sequence, boolean endOfBatch) throws Exception {
        System.out.println("Event："+event.getValue());
    }
}

（4）主函數：創建生產者，向ringbuffer中填充元素

public class DisruptorMain {

    public static void main(String[] agrs) throws InterruptedException {
        
        //創建線程池：
        Executor executor = Executors.newCachedThreadPool();

        //事件生產工廠：
        LongEventFactory longEventFactory = new LongEventFactory();

        //ringbuffer的大小：
        int bufferSize = 256;

        //實例化disruptor對象：初始化ringbuffer
         Disruptor<LongEvent> disruptor = new Disruptor<LongEvent>(longEventFactory, bufferSize, executor,ProducerType.SINGLE, new BlockingWaitStrategy());

        //設置事件的執行者：(單消費者)
        disruptor.handleEventsWith(new LongEventHandler());
        
        //disruptor啟動：
        disruptor.start();

        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();

        //設置事件單生產者：
        for(int x = 0;x<256; x++){
            // 獲取下一個可用位置的下標
            long sequence = ringBuffer.next();  
            try{
                // 返回可用位置的元素
                LongEvent event = ringBuffer.get(sequence); 
                // 設置該位置元素的值
                event.set(x); 
            }finally{
                //發布事件 
                ringBuffer.publish(sequence);
            }
            Thread.sleep(10);
        }
    }
}

1.4 Disruptor主要實現類

通過以上代碼，我們來簡單的分析下Disruptor的構成：

Disruptor：Disruptor的入口，主要封裝了環形隊列RingBuffer、消費者集合ConsumerRepository的引用；主要提供了獲取環形隊列、添加消費者、生產者向RingBuffer中添加事件（可以理解為生產者生產數據）的操作；

RingBuffer：Disruptor中隊列具體的實現，底層封裝了Object[]數組；在初始化時，會使用Event事件對數組進行填充，填充的大小就是bufferSize設置的值；此外，該對象內部還維護了Sequencer（序列生產器）具體的實現；

Sequencer：序列生產器，分別有MultiProducerSequencer（多生產者序列生產器） 和 SingleProducerSequencer（單生產者序列生產器）兩個實現類。上面的例子中，使用的是SingleProducerSequencer；在Sequencer中，維護了消費者的Sequence（序列對象）和生產者自己的Sequence（序列對象）；以及維護了生產者與消費者序列沖突時候的等待策略WaitStrategy；

Sequence：序列對象，內部維護了一個long型的value，這個序列指向了RingBuffer中Object[]數組具體的角標。生產者和消費者各自維護自己的Sequence；但都是指向RingBuffer的Object[]數組；

Wait Strategy：等待策略。當沒有可消費的事件時，消費者根據特定的策略進行等待；當沒有可生產的地方時，生產者根據特定的策略進行等待；

Event：事件對象，就是我們Ringbuffer中存在的數據，在Disruptor中用Event來定義數據，并不存在Event類，它只是一個定義；

EventProcessor：事件處理器，單獨在一個線程內執行，判斷消費者的序列和生產者序列關系，決定是否調用我們自定義的事件處理器，也就是是否可以進行消費；

EventHandler：事件處理器，由用戶自定義實現，也就是最終的事件消費者，需要實現EventHandler接口；

Producer：事件生產者，也就是我們上面代碼中最后那部門的for循環；

1.5 Disruptor的生產和消費

上面我們通過代碼簡單的實現了Disruptor，闡述其中具體實現類的含義，接下來再用圖文的方式進一步介紹Disruptor的生產和消費；

暫時還是以單生產和單消費者舉例：

（1）當Disruptor框架啟動：

（2）此時，還沒有數據進行寫入

（3）準備寫入數據前的準備，獲取可以寫入數據的最大序列；

（4）寫入數據完成，更新生產者序列對象的值；

以上，就是單生產者寫入數據的過程。要注意的是，無論是生產者還是消費者，序列的初始值都是-1；

當引入消費者后，生產者在獲取可寫入的序列之前，都會判斷消費者所處的序列。

我們假設一種情況，當在我們的消費者端使用Thread.sleep(巨大的值)的時候，消費者使用被等待，無法進行消費。

那么此時，生產者會一直對數組中的元素進行生產，當生產到7準備生產序列8的時候，通過計算序列8對應的是index = 0的元素，我們此時會判斷覆蓋點所對應的角標是否大于消費者的序列大小，如果大于消費者序列，那么生產者不會進行生產，直到消費者消費了此角標下的元素；

public long next(int n){
    if (n < 1)
    {
        throw new IllegalArgumentException("n must be > 0");
    }

    long nextValue = this.nextValue;

    long nextSequence = nextValue + n;
    long wrapPoint = nextSequence - bufferSize;
    long cachedGatingSequence = this.cachedValue;

    if (wrapPoint > cachedGatingSequence || cachedGatingSequence > nextValue){
        cursor.setVolatile(nextValue);  // StoreLoad fence

        long minSequence;
        //此處進行判斷，如果覆蓋點的大小，超過了消費者的序列，那么會一直while循環進行判斷
        while (wrapPoint > (minSequence = Util.getMinimumSequence(gatingSequences, nextValue))){
            waitStrategy.signalAllWhenBlocking();
            LockSupport.parkNanos(1L); // TODO: Use waitStrategy to spin?
        }

        this.cachedValue = minSequence;
    }

    this.nextValue = nextSequence;

    return nextSequence;
}

單消費者，進行消費的邏輯，與單生產者類似，大家可以進行深入研究；

以上便是單消費者和單生產者的大體流程；

下一篇，筆者將著重要介紹，Disruptor中使用的技術方案！！！