Distuptor高性能的无锁框架

最新推荐文章于 2024-07-21 22:27:18 发布

随身携带的笑

最新推荐文章于 2024-07-21 22:27:18 发布

阅读量399

点赞数 1

分类专栏：学习经验文章标签： java 数据库服务器

本文链接：https://blog.csdn.net/giveupgivedown/article/details/132503213

版权

学习经验专栏收录该内容

43 篇文章 0 订阅

订阅专栏

Distuptor介绍

初识Distuptor

它是一种高性能的无锁框架，适用于高并发业务场景，其实内部也就是一个生产者-消费者模型，有点类似于线程安全的SPSC队列

下面是它的基本概念

它是一个高性能的无锁并发框架，它使用环形缓冲区作为消息队列，能够实现高效的数据交换和事件处理

RingBuffer——Disruptor底层数据结构实现，核心类，是线程间交换数据的中转地；

Sequencer——序号管理器，生产同步的实现者，负责消费者/生产者各自序号、序号栅栏的管理和协调,Sequencer有单生产者,多生产者两种不同的模式,里面实现了各种同步的算法；

Sequence——序号，声明一个序号，用于跟踪ringbuffer中任务的变化和消费者的消费情况，disruptor里面大部分的并发代码都是通过对Sequence的值同步修改实现的,而非锁,这是disruptor高性能的一个主要原因；

SequenceBarrier——序号栅栏，管理和协调生产者的游标序号和各个消费者的序号，确保生产者不会覆盖消费者未来得及处理的消息，确保存在依赖的消费者之间能够按照正确的顺序处理

EventProcessor——事件处理器，监听RingBuffer的事件，并消费可用事件，从RingBuffer读取的事件会交由实际的生产者实现类来消费；它会一直侦听下一个可用的序号，直到该序号对应的事件已经准备好。

EventHandler——业务处理器，是实际消费者的接口，完成具体的业务逻辑实现，第三方实现该接口；代表着消费者。

Producer——生产者接口，第三方线程充当该角色，producer向RingBuffer写入事件。

Wait Strategy：Wait Strategy决定了一个消费者怎么等待生产者将事件（Event）放入Disruptor中。

数据结构

RingBuffer环形缓冲区，底层还是一个空间连续的数组，除数组外还有一个序列号(sequence)，用以指向下一个可用的元素，供生产者与消费者使用。

如图所示：
在这里插入图片描述

等待策略

下面是它的四种等待策略

BlockingWaitStrategy
阻塞等待策略是Disruptor的默认策略。在BlockingWaitStrategy内部是使用锁和condition来控制线程的唤醒。当消费者尝试从Disruptor中获取数据时，如果没有可用的数据，它将被阻塞，直到有新的数据可用或超时。BlockingWaitStrategy是最低效的策略，但其对CPU的消耗最小并且在各种不同部署环境中能提供更加一致的性能表现。

SleepingWaitStrategy
休眠等待策略，SleepingWaitStrategy在等待期间使用循环加上Thread.sleep()方法来让出CPU资源，减少忙等待时的CPU占用。没有可用数据时，消费者线程将进行自旋等待一段时间，然后休眠一小段时间，再次尝试获取数据。适用于对延迟要求较高的场景，因为它能够在一定程度上减少CPU的占用，但也可能导致一定的延迟增加。

YieldingWaitStrategy
让步等待策略是可以使用在低延迟系统的策略之一。等待期间使用Thread.yield()方法来让出CPU资源，将执行机会让给其他线程。在要求极高性能且事件处理线数小于 CPU 逻辑核心数的场景中，推荐使用此策略

BusySpinWaitStrategy
忙等待策略性能最好，适合用于低延迟的系统。使用循环不断尝试获取数据，不会让出CPU资源。在要求极高性能且事件处理线程数小于CPU逻辑核心数的场景中，推荐使用此策略；例如，CPU开启超线程的特性。

PhasedBackoffWaitStrategy
使用自旋 + yield + 自定义策略，使用于CPU资源紧张，吞吐量和延迟并不重要的场景。

一般来说，BlockingWaitStrategy适用于对性能要求不高的场景，SleepingWaitStrategy适用于对延迟相对较敏感的场景，YieldingWaitStrategy适用于低延迟和高并发的场景，BusySpinWaitStrategy适用于对延迟要求非常高且并发度较高的场景

Distuptor性能

Disruptor的的延时和吞吐量都比ArrayBlockingQueue优秀很多
它比jdk内置的几款队列性能更好的原因是，采用了cas这种无锁策略，而且，它对cpu是十分友好的

预分配内存

它在一开始时就创建了一块空间连续的环形缓冲区，于存储环形队列和事件对象，提高了数据的局部性和缓存命中率也避免后续不断的申请内存和内存释放。

使用cpu-cache

一般我们的代码是处于内存级别的，而Distuptor利用到了高速缓存区cpu-cache，二者读写速度相差百倍
采用缓冲行填充策略，保证数据一直处于cpu-cache中，不会被写入主存，享受cpu缓存的高速读写

缓冲行填充
CPU缓存以缓存行（Cache Line）为单位进行读写操作，通常是64字节。Disruptor利用缓存行填充的概念，确保相关的数据结构在同一个缓存行中，避免多个线程在同一时间修改同一个缓存行中的不同数据，从而减少缓存行的伪共享现象。

Disruptor会对事件对象进行缓存行对齐，确保每个事件对象占用整个缓存行。这样做的目的是避免多个事件对象在同一个缓存行中，减少缓存行的伪共享现象。

数据结构

数组结构适合cpu的多级流水线以及cpu的分支预测，降低后续操作执行的时间成本

Distuptor使用

Distuptor配置步骤

1.定义事件对象：首先，你需要定义一个事件对象，该对象包含需要在不同线程间传递的数据。

public class YourEvent {
    // 定义事件数据的成员变量
}

2.定义事件处理器（消费者）：创建一个或多个事件处理器，用于处理事件对象。

public class YourEventHandler implements EventHandler<YourEvent> {
    public void onEvent(YourEvent event, long sequence, boolean endOfBatch) {
        // 处理事件数据
    }
}

3.创建 Disruptor 实例：使用 Disruptor 的 create 方法创建一个 Disruptor 实例，并设置环形缓冲区的大小和事件工厂。

int bufferSize = 1024;
Disruptor<YourEvent> disruptor = new Disruptor<>(YourEvent::new, bufferSize, Executors.defaultThreadFactory());

4.连接事件处理器：将事件处理器连接到 Disruptor 上。

disruptor.handleEventsWith(new YourEventHandler());

5.启动 Disruptor：使用 start 方法启动 Disruptor，开始事件处理。

disruptor.start();

6.发布事件：通过 Disruptor 的 publishEvent 方法发布事件，将事件数据发送到环形缓冲区。

RingBuffer<YourEvent> ringBuffer = disruptor.getRingBuffer();
long sequence = ringBuffer.next();
YourEvent event = ringBuffer.get(sequence);
// 设置事件数据
ringBuffer.publish(sequence);

单/多生产者策略

使用单个消费者：

最简单的方式是只使用一个消费者线程来消费消息。这样可以确保消息按照生产者发布的顺序被处理，因为只有一个消费者在处理消息。

使用多个消费者：

但每个消费者处理的消息顺序保持一致
如果需要使用多个消费者线程来并行处理消息，但仍要保持消息的顺序性，可以采用以下策略：

使用Disruptor的WorkProcessor来创建消费者线程。WorkProcessor会确保每个消费者线程只处理自己的独立消息序列，并保持消息的顺序性。这样，每个消费者线程都可以独立地处理消息，而不会与其他消费者线程产生竞争。
在消息中添加序列号或时间戳等标识，消费者在处理消息时根据这些标识来进行排序。消费者可以在接收到消息后，根据标识进行排序，确保消息按照指定的顺序进行处理。