disruptor并发框架-异步线程

disruptor框架：是一个开源的并发框架、高效能的异步处理框架、“生产者-消费者设计模式”，其核心是业务核心处理器，可以在一个线程中每秒处理600万订单

 “生产者-消费者设计模式”：

 

 框架实现主要由以下部分构成

1.创建数据实体类（即对于要实现异步的方法数据实体类）Event

//1.数据实体类
public class LongEvent {
    private long value;

    public long getValue() {
        return value;
    }

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

2.事件工厂EventFactory

//2.创建工厂类（相当于缓冲区），会在disruptor系统初始化时，构造对象实例
public class LongEventFactory implements EventFactory<LongEvent>{

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

}

3.消费者，事件处理器（eventHandler和WorkHandler，两者区别是将多个eventHandler的实现类传入，每个消费者都会对同一条消息进行独立消费，消费者之间不存在竞争；多个WorkHandler的实现类传入

，不会重复消费，即消费者A对消息A进行消费，消费者B不会在对消息A进行消费）

//3.创建消费者类
public class LongWorkHandler implements WorkHandler<LongEvent>{
    //onEvent是回调方法
    public void onEvent(LongEvent event) throws Exception {
        // TODO 异步方法的实现，可以将具体实现的逻辑封装成一个方法，然后在这里直接调用
        //这里就简单的展示输入方法
        System.out.println(event.getValue());
    }
}

4.生产者

//4.创建生产者类
public class LongEventProducer {
    // 环形缓冲区，装载生产好的数据
    private final RingBuffer<LongEvent> ringBuffer;
    // 构造方法
    public LongEventProducer(RingBuffer<LongEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }
    // 将数据推入到环形缓冲区
    public void onData(int i) {
        long sequence = ringBuffer.next();// 请求下一个事件序号
        try {
            LongEvent event = ringBuffer.get(sequence);// 获取该序号对应的事件对象
            //设置实体类数据
            event.setValue(i);
        } finally {
            ringBuffer.publish(sequence);// 数据发布，只有发布后的数据才能被消费者看见
        }
    }
}

5.测试

//5.测试类
public class LongEventMain {
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        // 创建线程池
        Executor executor = Executors.newCachedThreadPool();
        // 事件工厂
        LongEventFactory factory = new LongEventFactory();
        // 定义缓冲区大小
        int bufferSize = 1024;
        // ProducerType.SINGLE:多消费者 new BlockingWaitStrategy()：等待策略
        Disruptor<LongEvent> disruptor = new Disruptor<LongEvent>(factory, bufferSize, executor, ProducerType.SINGLE,
                new BlockingWaitStrategy());
        // 创建一个消费者
        LongWorkHandler workHandler = new LongWorkHandler();
        // 消费者事件处理方法
        disruptor.handleEventsWithWorkerPool(workHandler);
        // 线程启动
        disruptor.start();
        // Disruptor 的事件发布过程是一个两阶段提交的过程：
        // 发布事件
        RingBuffer<LongEvent> ringBuffer = disruptor.getRingBuffer();

        // 定义生产者
        LongEventProducer producer = new LongEventProducer(ringBuffer);

        for (int l = 0; l < 10; l++) {
            producer.onData(l);// 调用方法
        }
        disruptor.shutdown();// 关闭 disruptor，方法会堵塞，直至所有的事件都得到处理；
        ((ExecutorService) executor).shutdown();// 关闭 disruptor
                                                // 使用的线程池；如果需要的话，必须手动关闭，
                                                // disruptor 在 shutdown 时不会自动关闭；
    }
}

6.结果