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中使用的技術方案！！！
