高性能内存队列Disruptor使用

最新推荐文章于 2024-04-28 12:35:07 发布

yulang1992514

最新推荐文章于 2024-04-28 12:35:07 发布

阅读量877

点赞数

分类专栏： java并发编程文章标签： java Powered by 金山文档

本文链接：https://blog.csdn.net/yulang1992514/article/details/129444801

版权

java并发编程专栏收录该内容

4 篇文章 0 订阅

订阅专栏

认识Disruptor

Disruptor是一个开源框架，研发的初衷是为了解决高并发下列队锁的问题，最早由 LMAX（一种新型零售金融交易平台）提出并使用，能够在无锁的情况下实现队列的并发操作，并号称能够在一个线程里每秒处理6百万笔订单(这个真假就不清楚了！牛皮谁都会吹)。

Github：https://github.com/LMAX-Exchange/disruptor

Disruptor实现了队列的功能并且是一个有界队列，可以用于生产者-消费者模型。

讲到生产消费模型，大家应该马上就能回忆起前面我们已经学习过的BlockingQueue 课程，里面我们学习过多种队列，但是这些队列大多是基于条件阻塞方式的，性能还不够优秀！

juc下队列存在的问题

队列	描述
ArrayBlockingQueue	基于数组结构实现的一个有界阻塞队列
LinkedBlockingQueue	基于链表结构实现的一个无界阻塞队列，指定容量为有界阻塞队列
PriorityBlockingQueue	支持按优先级排序的无界阻塞队列
DelayQueue	基于优先级队列（PriorityBlockingQueue）实现的无界阻塞队列
SynchronousQueue	不存储元素的阻塞队列
LinkedTransferQueue	基于链表结构实现的一个无界阻塞队列
LinkedBlockingDeque	基于链表结构实现的一个双端阻塞队列

1. juc下的队列大部分采用加ReentrantLock锁方式保证线程安全。在稳定性要求特别高的系统中，为了防止生产者速度过快，导致内存溢出，只能选择有界队列。

2. 加锁的方式通常会严重影响性能。线程会因为竞争不到锁而被挂起，等待其他线程释放锁而唤醒，这个过程存在很大的开销，而且存在死锁的隐患。

3. 有界队列通常采用数组实现。但是采用数组实现又会引发另外一个问题false sharing(伪共享)。

Disruptor的设计方案

Disruptor通过以下设计来解决队列速度慢的问题：

环形数组结构

为了避免垃圾回收，采用数组而非链表。同时，数组对处理器的缓存机制更加友好（空间局部性原理）。

元素位置定位

数组长度2^n，通过位运算，加快定位的速度。下标采取递增的形式。不用担心index溢出的问题。index是long类型，即使100万QPS的处理速度，也需要30万年才能用完。

无锁设计

每个生产者或者消费者线程，会先申请可以操作的元素在数组中的位置，申请到之后，直接在该位置写入或者读取数据。

利用缓存行填充解决了伪共享的问题

实现了基于事件驱动的生产者消费者模型（观察者模式）

消费者时刻关注着队列里有没有消息，一旦有新消息产生，消费者线程就会立刻把它消费

RingBuffer数据结构

使用RingBuffer来作为队列的数据结构，RingBuffer就是一个可自定义大小的环形数组。除数组外还有一个序列号(sequence)，用以指向下一个可用的元素，供生产者与消费者使用。原理图如下所示：

Disruptor要求设置数组长度为2的n次幂。在知道索引(index)下标的情况下，存与取数组上的元素时间复杂度只有O(1)，而这个index我们可以通过序列号与数组的长度取模来计算得出，index=sequence % entries.length。也可以用位运算来计算效率更高，此时array.length必须是2的幂次方，index=sequece&(entries.length-1)

当所有位置都放满了，再放下一个时，就会把0号位置覆盖掉

思考：能覆盖数据是否会导致数据丢失呢？

当需要覆盖数据时，会执行一个策略，Disruptor给提供多种策略，比较常用的：

BlockingWaitStrategy策略，常见且默认的等待策略，当这个队列里满了，不执行覆盖，而是阻塞等待。使用ReentrantLock+Condition实现阻塞，最节省cpu，但高并发场景下性能最差。适合CPU资源紧缺，吞吐量和延迟并不重要的场景

SleepingWaitStrategy策略，会在循环中不断等待数据。先进行自旋等待如果不成功，则使用Thread.yield()让出CPU,并最终使用LockSupport.parkNanos(1L)进行线程休眠，以确保不占用太多的CPU资源。因此这个策略会产生比较高的平均延时。典型的应用场景就是异步日志。

YieldingWaitStrategy策略，这个策略用于低延时的场合。消费者线程会不断循环监控缓冲区变化，在循环内部使用Thread.yield()让出CPU给别的线程执行时间。如果需要一个高性能的系统，并且对延时比较有严格的要求，可以考虑这种策略。

BusySpinWaitStrategy策略: 采用死循环，消费者线程会尽最大努力监控缓冲区的变化。对延时非常苛刻的场景使用，cpu核数必须大于消费者线程数量。推荐在线程绑定到固定的CPU的场景下使用

一个生产者单线程写数据的流程

申请写入m个元素；

若是有m个元素可以写入，则返回最大的序列号。这里主要判断是否会覆盖未读的元素；

若是返回的正确，则生产者开始写入元素。

多个生产者写数据的流程

多个生产者的情况下，会遇到“如何防止多个线程重复写同一个元素”的问题。Disruptor的解决方法是每个线程获取不同的一段数组空间进行操作。这个通过CAS很容易达到。只需要在分配元素的时候，通过CAS判断一下这段空间是否已经分配出去即可。

但是会遇到一个新问题：如何防止读取的时候，读到还未写的元素。Disruptor在多个生产者的情况下，引入了一个与Ring Buffer大小相同的buffer：available Buffer。当某个位置写入成功的时候，便把availble Buffer相应的位置置位，标记为写入成功。读取的时候，会遍历available Buffer，来判断元素是否已经就绪。

消费者读数据

生产者多线程写入的情况下读数据会复杂很多：

申请读取到序号n；

若writer cursor >= n，这时仍然无法确定连续可读的最大下标。从reader cursor开始读取available Buffer，一直查到第一个不可用的元素，然后返回最大连续可读元素的位置；

消费者读取元素。

如下图所示，读线程读到下标为2的元素，三个线程Writer1/Writer2/Writer3正在向RingBuffer相应位置写数据，写线程被分配到的最大元素下标是11。读线程申请读取到下标从3到11的元素，判断writer cursor>=11。然后开始读取availableBuffer，从3开始，往后读取，发现下标为7的元素没有生产成功，于是WaitFor(11)返回6。然后，消费者读取下标从3到6共计4个元素。

多个生产者写数据

多个生产者写入的时候：

申请写入m个元素；

若是有m个元素可以写入，则返回最大的序列号。每个生产者会被分配一段独享的空间；

生产者写入元素，写入元素的同时设置available Buffer里面相应的位置，以标记自己哪些位置是已经写入成功的。

如下图所示，Writer1和Writer2两个线程写入数组，都申请可写的数组空间。Writer1被分配了下标3到下表5的空间，Writer2被分配了下标6到下标9的空间。Writer1写入下标3位置的元素，同时把available Buffer相应位置置位，标记已经写入成功，往后移一位，开始写下标4位置的元素。Writer2同样的方式。最终都写入完成。

Disruptor核心概念

RingBuffer（环形缓冲区）：基于数组的内存级别缓存，是创建sequencer(序号)与定义WaitStrategy(拒绝策略)的入口。

Disruptor（总体执行入口）：对RingBuffer的封装，持有RingBuffer、消费者线程池Executor、消费之集合ConsumerRepository等引用。

Sequence（序号分配器）：对RingBuffer中的元素进行序号标记，通过顺序递增的方式来管理进行交换的数据(事件/Event)，一个Sequence可以跟踪标识某个事件的处理进度，同时还能消除伪共享。

Sequencer（数据传输器）：Sequencer里面包含了Sequence，是Disruptor的核心，Sequencer有两个实现类：SingleProducerSequencer(单生产者实现)、MultiProducerSequencer(多生产者实现)，Sequencer主要作用是实现生产者和消费者之间快速、正确传递数据的并发算法

SequenceBarrier（消费者屏障）：用于控制RingBuffer的Producer和Consumer之间的平衡关系，并且决定了Consumer是否还有可处理的事件的逻辑。

WaitStrategy（消费者等待策略）：决定了消费者如何等待生产者将Event生产进Disruptor，WaitStrategy有多种实现策略

Event：从生产者到消费者过程中所处理的数据单元，Event由使用者自定义。

EventHandler：由用户自定义实现，就是我们写消费者逻辑的地方，代表了Disruptor中的一个消费者的接口。

EventProcessor：这是个事件处理器接口，实现了Runnable，处理主要事件循环，处理Event，拥有消费者的Sequence

框架使用

在项目中我们废弃了原有的juc下的队列，采用了Disruptor这个框架来进行操作日志的处理

   构造函数   
   public Disruptor(
            final EventFactory<T> eventFactory,  //创建事件（任务）的工厂类
            final int ringBufferSize,  // 数组大小
            final ThreadFactory threadFactory,  //用于创建线程的工厂
            final ProducerType producerType,  // 生产这类型 单个生产个 多个生产这
            final WaitStrategy waitStrategy)  //等待策略

maven依赖

<!--  disruptor 高速队列-->
<dependency>
    <groupId>com.lmax</groupId>
    <artifactId>disruptor</artifactId>
    <version>3.4.2</version>
</dependency>

创建event事件和事件工厂

      /**
     * 创建事件（任务）的工厂类
     *
     * @return {@link EventFactory }<{@link BizHanderEvent }>    返回值类型
     * @author 余浪
     */
    @Bean
    public EventFactory<BizHanderEvent> eventEventFactory() {

        EventFactory<BizHanderEvent> orderEventEventFactory = new EventFactory<BizHanderEvent>() {
            @Override
            public BizHanderEvent newInstance() {
                return new BizHanderEvent();
            }
        };
        return orderEventEventFactory;
    }


/**
 * 业务事件
 *
 * @Date: 2021/3/10 14:33
 * @Version: 1.0.0
 **/
@Data
public class BizHanderEvent implements Serializable {

    /**
     * 时间戳
     */
    private final long timestamp;

    /**
     * 事件携带的数据
     */
    protected transient Object source;

    public BizHanderEvent() {
        this.timestamp = System.currentTimeMillis();
    }

    public BizHanderEvent(Object source) {
        this.timestamp = System.currentTimeMillis();
        this.source = source;
    }
}

创建消费者handler

package com.cloud.common.log.disruptor;

import cn.hutool.core.lang.UUID;
import com.cloud.common.core.disruptor.BizHanderEvent;
import com.cloud.common.log.dao.LogInfoDao;
import com.cloud.common.log.model.SysLog;
import com.lmax.disruptor.EventHandler;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.IdGenerator;

import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;


/**
 * 该对象 有多个: 和Symbol的数据对应
 * 针对某一个 LogEventHandler,只会同一时间有一个线程来执行它
 *
 * @author yulang
 */
@Data
@Slf4j
public class LogEventHandler implements EventHandler<BizHanderEvent> {

    private LogInfoDao logInfoDao;

    private volatile List<SysLog> list = Collections.synchronizedList(new ArrayList<SysLog>(36));

    private Integer batchLogSize;

    public LogEventHandler(LogInfoDao logInfoDao,Integer batchLogSize) {
        this.logInfoDao = logInfoDao;
        if(batchLogSize==null || batchLogSize < 5){
            batchLogSize = 15;
        }
        this.batchLogSize = batchLogSize;
    }

    /**
     * 接收到了某个消息
     *
     * @param event
     * @param sequence
     * @param endOfBatch
     * @throws Exception
     */
    @Override
    public void onEvent(BizHanderEvent event, long sequence, boolean endOfBatch) throws Exception {

        log.info("开始接收log事件============>{}-- sequence:{} -- endOfBatch:{} ", event, sequence, endOfBatch);

        // 从ringbuffer 里面接收了某个数据
        SysLog order = (SysLog) event.getSource();
        order.setUpdateTime(LocalDateTime.now());
        order.setId(IdWorkerUtil.getId());
        list.add(order);
        if (list.size() >= batchLogSize) {
            logInfoDao.addLogs(list);
            list.clear();
        }
        log.info("处理完成我们的log事件===================>{}", event);
    }
}

定义生产者事件

package com.cloud.common.log.disruptor;

import com.cloud.common.core.disruptor.BizHanderEvent;
import com.cloud.common.log.model.SysLog;
import com.lmax.disruptor.EventTranslatorOneArg;
import com.lmax.disruptor.RingBuffer;

/**
 * 在boot里面使用它发送消息
 */
@compent
public class DisruptorTemplate {

    private static final EventTranslatorOneArg<BizHanderEvent, SysLog> TRANSLATOR = new EventTranslatorOneArg<BizHanderEvent, SysLog>() {

        @Override
        public void translateTo(BizHanderEvent event, long sequence, SysLog input) {
            event.setSource(input);
        }
    };
    private final RingBuffer<BizHanderEvent> ringBuffer;

    public DisruptorTemplate(RingBuffer<BizHanderEvent> ringBuffer) {
        this.ringBuffer = ringBuffer;
    }

    /**
     * 我们使用DisruptorTemplate 时,就使用它的onData方法
     *
     * @param input
     */
    public void onData(SysLog input) {
        ringBuffer.publishEvent(TRANSLATOR, input);
    }
}

其他一些相关的配置类

package com.cloud.common.core.disruptor;

import com.lmax.disruptor.*;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
//import net.openhft.affinity.AffinityThreadFactory;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.concurrent.ThreadFactory;

import static java.util.concurrent.Executors.defaultThreadFactory;

/**
 *
 *  传统的内存队列如果需要保存线程安全 通过锁 来实现，
 *  或者是通过 cas 实现，而 volatile类型的变量进行 CAS 操作，存在伪共享问题
 *
 *   多核cpu下 ，现在主流的CPU都是多核心（超核）的处理器，每一个核心可以同时执行一个线程，那么计算机在同一时刻就可以执行多条线程（中的指令），
 *   由于程序的局部性原理，当多个线程在执行时需要处理物理位置相近的数据时，就会同时将位于同一个缓存行的数据load到缓冲中，
 *   多条线程处理了数据时会发现缓存失效的问题，重新从内存中load数据，造成多个线程相互影响，形成伪共享。
 *
 *  缓存伪共享
 * 共享对象存在同一个缓存中，由于MESI协议，一个对象中一些不需要改变的属性因为其他改变的属性，导致整个对象的缓存进入到M被修改状态
 *
 * 目前的CPU是按照64K的缓存行(Cache Line)进行读取，如果读取的数据在同一个CacheLine，就存在缓存伪共享的问题。
 *
 * 对象被放入一个CacheLine中，根据MSEI协议，其中一个属性改变，其他所有没有改变的属性也变得不可共享。
 *
 * 填充Cache Line缓存块
 * 通过填充对象，将对象中常被改变的属性和不常改变的属性分开到不通缓存Cache Line中。避免缓存的伪共享。
 *
 *
 *   Disruptor  中的   com.lmax.disruptor.Sequence  类包装了一个volatile修饰的 long类型数据 value，无论是Disruptor中的基于数组实现的
 *   缓冲区RingBuffer
 *   value 前后被包围了 7个 long类型的值 ，对于一个大小为64字节的缓存行，它刚好被填补满 所以不会出现伪共享问题
 *
 *
 * @author: 余浪
 * @date:  2021/9/5
 **/
@Configuration
@EnableConfigurationProperties(value = DisruptorProperties.class)
public class DisruptorAutoConfiguration {

    public DisruptorProperties disruptorProperties;

    public DisruptorAutoConfiguration(DisruptorProperties disruptorProperties) {
        this.disruptorProperties = disruptorProperties;
    }


    /**
     * 创建事件（任务）的工厂类
     *
     * @return {@link EventFactory }<{@link BizHanderEvent }>    返回值类型
     * @author 余浪
     */
    @Bean
    public EventFactory<BizHanderEvent> eventEventFactory() {

        EventFactory<BizHanderEvent> orderEventEventFactory = new EventFactory<BizHanderEvent>() {
            @Override
            public BizHanderEvent newInstance() {
                return new BizHanderEvent();
            }
        };
        return orderEventEventFactory;
    }


    /**
     * 用于创建执行任务的线程。
     *
     * @return {@link ThreadFactory }    返回值类型
     * @author 余浪
     */
    @Bean
    public ThreadFactory threadFactory() {
        return defaultThreadFactory();
    }


    /**
     * 无锁高效的等待策略
     *
     * @return
     */
    @Bean
    public WaitStrategy waitStrategy() {
        return new SleepingWaitStrategy();
    }

    /**
     * 创建一个RingBuffer
     * eventFactory: 事件工厂
     * threadFactory:   我们执行者(消费者)的线程该怎么创建
     * waitStrategy : 等待策略: 当我们ringBuffer 没有数据时,我们怎么等待
     */
    @Bean
    public RingBuffer<BizHanderEvent> ringBuffer(
            EventFactory<BizHanderEvent> eventFactory,
            ThreadFactory threadFactory,
            WaitStrategy waitStrategy,
            EventHandler<BizHanderEvent>[] eventHandlers) {

        /**
         * 构建disruptor
         */
        Disruptor<BizHanderEvent> disruptor = null;

        ProducerType producerType = ProducerType.SINGLE;

        if (disruptorProperties.isMultiProducer()) {
            producerType = ProducerType.MULTI;
        }

        disruptor = new Disruptor<BizHanderEvent>(eventFactory, disruptorProperties.getRingBufferSize(), threadFactory, producerType, waitStrategy);
        disruptor.setDefaultExceptionHandler(new DisruptorHandlerException());

        // 设置消费者---我们的每个消费者代表我们的一个 消息对,有多少个消息对,我们就有多少个eventHandlers ,事件来了后,多个eventHandlers 是并发执行的

        disruptor.handleEventsWith(eventHandlers);

        RingBuffer<BizHanderEvent> ringBuffer = disruptor.getRingBuffer();
        disruptor.start();// 开始监听


        final Disruptor<BizHanderEvent> disruptorShutdown = disruptor;

        // 使用优雅的停机
        Runtime.getRuntime().addShutdownHook(new Thread(
                () -> {
                    disruptorShutdown.shutdown();
                }, "DisruptorShutdownThread"
        ));
        return ringBuffer;
    }
}



/**
 * DisruptorHandlerException 的异常处理
 */
@Slf4j
public class DisruptorHandlerException implements ExceptionHandler {


    /**
     * <p>Strategy for handling uncaught exceptions when processing an event.</p>
     *
     * <p>If the strategy wishes to terminate further processing by the {@link BatchEventProcessor}
     * then it should throw a {@link RuntimeException}.</p>
     *
     * @param ex       the exception that propagated from the {@link EventHandler}.
     * @param sequence of the event which cause the exception.
     * @param event    being processed when the exception occurred.  This can be null.
     */
    @Override
    public void handleEventException(Throwable ex, long sequence, Object event) {
        log.info(" log into db error: {}", ex.getMessage());
        log.error("handleEventException Exception===>{} , sequence==> {} ,event===>{} ", ex.getMessage(), sequence, event);
    }

    /**
     * Callback to notify of an exception during {@link LifecycleAware#onStart()}
     *
     * @param ex throw during the starting process.
     */
    @Override
    public void handleOnStartException(Throwable ex) {
        log.info("OnStartHandler Exception===>{} ", ex.getMessage());
    }

    /**
     * Callback to notify of an exception during {@link LifecycleAware#onShutdown()}
     *
     * @param ex throw during the shutdown process.
     */
    @Override
    public void handleOnShutdownException(Throwable ex) {
        log.error("OnShutdownHandler Exception===>{} ", ex.getMessage());
    }
}

配置属性类
@Data
@ConfigurationProperties(prefix = "spring.disruptor")
public class DisruptorProperties {


    /**
     * 缓冲区的大小
     */
    private Integer ringBufferSize = 1024 * 1024;

    /**
     * 是否支持多生产者
     */
    private boolean isMultiProducer = false;
}

具体使用

package com.cloud.common.log.disruptor;

import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.cloud.common.core.exception.BizException;
import com.cloud.common.core.util.ResponseResult;
import com.cloud.common.core.util.SsoHolderUtil;
import com.cloud.common.core.util.TenantContextHolder;
import com.cloud.common.core.util.WebUtils;
import com.cloud.common.log.annotation.LogInfo;
import com.cloud.common.log.model.SysLog;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.jetbrains.annotations.NotNull;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 * 操作日志使用spring event异步入库
 */
@Slf4j
@SpringBootTest
public class SysLogTest {

    @Autowired
    private DisruptorTemplate disruptorTemplate;

    @Test
    public void logTest() {
       
        SysLog logVo = new SysLog();
        //生产日志数据 直接使用模板类进行生产消息即可
        disruptorTemplate.onData(logVo); 

    }
}