Disruptor并发框架完全入门

版本：3.4.2
前言：Disruptor拥有开飞机般的速度，单线程里每秒处理600w订单，业务逻辑处理器完全是运行在内存中的，是基于事件源驱动的。Disruptor作为一个高性能的异步处理框架，其为啥这么快？这也是我为啥尝试去学习它的原因。

Disruptor的使用
1. 建立一个Event类来承载数据，通过事件绑定数据的方式进行数据传递（在Disruptor中可以看作Event就是Data）
2. 建立一个Event工厂类，用来创建Event类的实例对象
3. 创建一个监听事件类，用于处理数据（监听事件类可看作为消费者，disruptor看作观察者，将消费者注册到观察者身上，一旦发生数据变动，观察者立即通知所有相关的消费者）
4. 环形缓冲区为Disruptor的真正核心，通过将消费者注册到disruptor中，生产者生产数据被disruptor保存到ringBuffer中，然后将数据当前的序列号通知给所有相关的消费者，消费者拿到相关的序列号，通过底层的取模运算找到要找的数据在环上的位置，然后直接到ringBuffer中读取数据。

代码来源官方文档：https://lmax-exchange.github.io/disruptor/
PS：代码后续附带其它详细解析

---

package disruptor;
/**
* @Description:    在disruptor中，Event代表数据，定义携带数据的事件
* @Author:         ljj
* @CreateDate:     2019/5/10 16:29
* @UpdateUser:     ljj
* @UpdateDate:     2019/5/10 16:29
* @UpdateRemark:   修改内容
* @Version:        1.0
*/
public class LongEvent {
    private long value;

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

    public long get(){
        return value;
    }
}

---

package disruptor;

import com.lmax.disruptor.EventFactory;

/**
 * @author ljj
 * @description 通过一个工厂来生产数据(Event)
 * @date 2019/5/10
 */
public class LongEventFactory implements EventFactory<LongEvent> {

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

---

package disruptor;

import com.lmax.disruptor.EventHandler;

/**
 * @author ljj
 * @description 在定义了Event之后我们需要创建一个消费者来处理这些事件，也是一个事件处理器
 * @date 2019/5/10
 */
public class LongEventHandler implements EventHandler<LongEvent> {
    private String clientName;

    LongEventHandler(String clientName){
        this.clientName = clientName;
    }

    //事件监听，类似观察者模式
    @Override
    public void onEvent(LongEvent event, long sequence, boolean endOfBatch) throws Exception {
//        System.out.println(this.clientName + event.get());//向Client推送消息
        event.get();
    }
}

---

package disruptor;

import com.lmax.disruptor.RingBuffer;

import java.nio.ByteBuffer;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * @author ljj
 * @description
 * @date 2019/5/10
 */
public class LongEventProducer {
    private final RingBuffer<LongEvent> ringBuffer;

    public LongEventProducer(RingBuffer<LongEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    //发布事件
    public void onData(ByteBuffer bb){
        long sequence = ringBuffer.next();              //1.获取下一个序列
        try {
            LongEvent event = ringBuffer.get(sequence); //2.获取disruptor的sequence
            event.set(bb.getLong(0));             //3.设置事件Context
        }finally {
            ringBuffer.publish(sequence);               //4.发布事件
        }
    }
}

---

package disruptor;

import com.lmax.disruptor.EventTranslatorOneArg;
import com.lmax.disruptor.RingBuffer;

import java.nio.ByteBuffer;

/**
 * @author ljj
 * @description 在disruptor3.0版本中。添加了一个更丰富的lambda风格的API，
 * 通过将这种复杂性封装在ringBuffer(环形缓冲区)来帮助开发人员，因此post-3.0
 * 之后发布消息可以通过Event Publisher(事件发布者)或者Event Translator(事件转换器)
 * 来进行事件发布
 * 优点：这种方法的优点就是可以将转换程序代码放置到单独的类，并且可以轻松的进行单元测试Disruptor
 * 提供类许多不同的接口(EventTranslator、EventTranslatorOneArg、EventTran