从构建分布式秒杀系统聊聊Disruptor高性能队列

时间 2019-12-06

原文原文链接

前言

秒杀架构持续优化中，基于自身认知不足之处在所不免，也请你们指正，共同进步。文章标题来自码友<tukangzheng>的建议，但愿能够把阻塞队列ArrayBlockingQueue这个队列替换成Disruptor，因为以前曾接触过这个东西，据说很不错，正好借此机会整合进来。html

简介

LMAX Disruptor是一个高性能的线程间消息库。它源于LMAX对并发性，性能和非阻塞算法的研究，现在构成了Exchange基础架构的核心部分。面试

Disruptor它是一个开源的并发框架，并得到2011 Duke’s 程序框架创新奖，可以在无锁的状况下实现网络的Queue并发操做。算法
Disruptor是一个高性能的异步处理框架，或者能够认为是最快的消息框架（轻量的JMS），也能够认为是一个观察者模式的实现，或者事件监听模式的实现。

在这里你能够跟BlockingQueue队列做比对，简单的理解为它是一种高效的"生产者-消费者"模型，先了解后深刻底层原理。shell

核心

写代码案例以前，你们最好先了解 Disruptor 的核心概念，至少知道它是如何运做的。缓存

Ring Buffer
如其名，环形的缓冲区。曾经 RingBuffer 是 Disruptor 中的最主要的对象，但从3.0版本开始，其职责被简化为仅仅负责对经过 Disruptor 进行交换的数据（事件）进行存储和更新。在一些更高级的应用场景中，Ring Buffer 能够由用户的自定义实现来彻底替代。
Sequence Disruptor
经过顺序递增的序号来编号管理经过其进行交换的数据（事件），对数据(事件)的处理过程老是沿着序号逐个递增处理。一个 Sequence 用于跟踪标识某个特定的事件处理者( RingBuffer/Consumer )的处理进度。虽然一个 AtomicLong 也能够用于标识进度，但定义 Sequence 来负责该问题还有另外一个目的，那就是防止不一样的 Sequence 之间的CPU缓存伪共享(Flase Sharing)问题。
Sequencer
Sequencer 是 Disruptor 的真正核心。此接口有两个实现类 SingleProducerSequencer、MultiProducerSequencer ，它们定义在生产者和消费者之间快速、正确地传递数据的并发算法。
Sequence Barrier
用于保持对RingBuffer的 main published Sequence 和Consumer依赖的其它Consumer的 Sequence 的引用。 Sequence Barrier 还定义了决定 Consumer 是否还有可处理的事件的逻辑。
Wait Strategy
定义 Consumer 如何进行等待下一个事件的策略。（注：Disruptor 定义了多种不一样的策略，针对不一样的场景，提供了不同的性能表现）
Event
在 Disruptor 的语义中，生产者和消费者之间进行交换的数据被称为事件(Event)。它不是一个被 Disruptor 定义的特定类型，而是由 Disruptor 的使用者定义并指定。
EventProcessor
EventProcessor 持有特定消费者(Consumer)的 Sequence，并提供用于调用事件处理实现的事件循环(Event Loop)。
EventHandler
Disruptor 定义的事件处理接口，由用户实现，用于处理事件，是 Consumer 的真正实现。
Producer
即生产者，只是泛指调用 Disruptor 发布事件的用户代码，Disruptor 没有定义特定接口或类型。

优势

剖析Disruptor:为何会这么快？(一)锁的缺点
剖析Disruptor:为何会这么快？(二)神奇的缓存行填充
剖析Disruptor:为何会这么快？(三)伪共享
剖析Disruptor:为何会这么快？(四)揭秘内存屏障

有兴趣的参考：
https://coolshell.cn/articles/9169.html网络

https://www.cnblogs.com/daoqidelv/p/6995888.html架构

使用案例

这里以咱们系统中的秒杀做为案例，后面有相对复杂的场景介绍。并发

定义秒杀事件对象：框架

/**
 * 事件对象（秒杀事件）
 * 建立者 科帮网
 */
public class SeckillEvent implements Serializable {
    private static final long serialVersionUID = 1L;
    private long seckillId;
    private long userId;

    public SeckillEvent(){

    }

    public long getSeckillId() {
        return seckillId;
    }

    public void setSeckillId(long seckillId) {
        this.seckillId = seckillId;
    }

    public long getUserId() {
        return userId;
    }

    public void setUserId(long userId) {
        this.userId = userId;
    }
}

为了让Disruptor为咱们预先分配这些事件，咱们须要一个将执行构造的EventFactory：异步

/**
 * 事件生成工厂（用来初始化预分配事件对象）
 * 建立者 科帮网
 */
public class SeckillEventFactory implements EventFactory<SeckillEvent> {

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

而后，咱们须要建立一个处理这些事件的消费者：

/**
 * 消费者(秒杀处理器)
 * 建立者 科帮网
 */
public class SeckillEventConsumer implements EventHandler<SeckillEvent> {
    //业务处理、这里是没法注入的，须要手动获取，见源码
    private ISeckillService seckillService = (ISeckillService) SpringUtil.getBean("seckillService");

    public void onEvent(SeckillEvent seckillEvent, long seq, boolean bool) throws Exception {
        seckillService.startSeckil(seckillEvent.getSeckillId(), seckillEvent.getUserId());
    }
}

既然有消费者，咱们将须要这些秒杀事件的来源：

/**
 * 使用translator方式生产者
 * 建立者 科帮网
 */
public class SeckillEventProducer {

    private final static EventTranslatorVararg<SeckillEvent> translator = new EventTranslatorVararg<SeckillEvent>() {
        public void translateTo(SeckillEvent seckillEvent, long seq, Object... objs) {
            seckillEvent.setSeckillId((Long) objs[0]);
            seckillEvent.setUserId((Long) objs[1]);
        }
    };

    private final RingBuffer<SeckillEvent> ringBuffer;

    public SeckillEventProducer(RingBuffer<SeckillEvent> ringBuffer){
        this.ringBuffer = ringBuffer;
    }

    public void seckill(long seckillId, long userId){
        this.ringBuffer.publishEvent(translator, seckillId, userId);
    }
}

最后，咱们来写一个测试类，运行一下(跑不通，须要修改消费者)：

/**
 * 測試類
 * 建立者 科帮网
 */
public class SeckillEventMain {

    public static void main(String[] args) {
        producerWithTranslator();
    }
    public static void producerWithTranslator(){
        SeckillEventFactory factory = new SeckillEventFactory();
        int ringBufferSize = 1024;
        ThreadFactory threadFactory = new ThreadFactory() {
            public Thread newThread(Runnable runnable) {
                return new Thread(runnable);
            }
        };
        //建立disruptor
        Disruptor<SeckillEvent> disruptor = new Disruptor<SeckillEvent>(factory, ringBufferSize, threadFactory);
        //链接消费事件方法
        disruptor.handleEventsWith(new SeckillEventConsumer());
        //启动
        disruptor.start();
        RingBuffer<SeckillEvent> ringBuffer = disruptor.getRingBuffer();
        SeckillEventProducer producer = new SeckillEventProducer(ringBuffer);
        for(long i = 0; i<10; i++){
            producer.seckill(i, i);
        }
        disruptor.shutdown();//关闭 disruptor，方法会堵塞，直至全部的事件都获得处理；
    }
}

使用场景

PCP （生产者-消费者问题）
网上搜了下国内实战案例并很少，大厂可能有在使用

这里举一个你们平常的例子，停车场景。当汽车进入停车场时(A)，系统首先会记录汽车信息(B)。同时也会发送消息到其余系统处理相关业务(C)，最后发送短信通知车主收费开始(D)。

一个生产者A与三个消费者B、C、D，D的事件处理须要B与C先完成。则该模型结构以下：

在这个结构下，每一个消费者拥有各自独立的事件序号Sequence，消费者之间不存在共享竞态。SequenceBarrier1监听RingBuffer的序号cursor，消费者B与C经过SequenceBarrier1等待可消费事件。SequenceBarrier2除了监听cursor，同时也监听B与C的序号Sequence，从而将最小的序号返回给消费者D，由此实现了D依赖B与C的逻辑。

欢迎工做一到五年的 Java 的工程师朋友们加入的 Java 架构开发：6851-67-672

本群提供免费的学习指导架构资料以及免费的解答

不懂得问题均可以在本群提出来以后还会有职业生涯规划以及面试指导