Disruptor的介绍
- Disruptor是英国外汇交易公司LMAX开发的一个高性能队列，研发的初衷是解决内存队列的延迟问题（在性能测试中发现竟然与I/O操作处于同样的数量级）。
- 基于Disruptor开发的系统单线程能支撑每秒600万订单，2010年在QCon演讲后，获得了业界关注。
- 目前，包括Apache Storm、Camel、Log4j 2在内的很多知名项目都应用了Disruptor以获取高性能。这里所说的队列是系统内部的内存队列，而不是Kafka这样的分布式队列。
- Disruptor实现了队列的功能并且是一个有界队列，可以用于生产者-消费者模型。
为什么要有Disruptor，juc下队列存在的问题
- juc下的队列大部分采用加ReentrantLock锁方式保证线程安全。在稳定性要求特别高的系统中，为了防止生产者速度过快，导致内存溢出，只能选择有界队列。
- 加锁的方式通常会严重影响性能。线程会因为竞争不到锁而被挂起，等待其他线程释放锁而唤醒，这个过程存在很大的开销，而且存在死锁的隐患。
- 有界队列通常采用数组实现。但是采用数组实现又会引发另外一个问题false sharing(伪共享)。
Disruptor如何解决上述问题（设计精髓！）
- 环形数组结构：为了避免垃圾回收，采用数组而非链表。同时，数组对处理器的缓存机制更加友好（空间局部性原理）。
- 元素位置定位：数组长度2^n，通过位运算，加快定位的速度。下标采取递增的形式。不用担心index溢出的问题。index是long类型，即使100万QPS的处理速度，也需要30万年才能用完。
- 无锁设计：每个生产者或者消费者线程，会先申请可以操作的元素在数组中的位置，申请到之后，直接在该位置写入或者读取数据。
- 利用缓存行填充解决了伪共享的问题。
- 实现了基于事件驱动的生产者消费者模型（观察者模式）：消费者时刻关注着队列里有没有消息，一旦有新消息产生，消费者线程就会立刻把它消费。
Disruptor的环形数组覆盖策略
- BlockingWaitStrategy策略：常见且默认的等待策略，当这个队列里满了，不执行覆盖，而是阻塞等待。使用ReentrantLock+Condition实现阻塞，最节省cpu，但高并发场景下性能最差。适合CPU资源紧缺，吞吐量和延迟并不重要的场景
- SleepingWaitStrategy策略：会在循环中不断等待数据。先进行自旋等待如果不成功，则使用Thread.yield()让出CPU,并最终使用LockSupport.parkNanos(1L)进行线程休眠，以确保不占用太多的CPU资源。因此这个策略会产生比较高的平均延时。典型的应用场景就是异步日志。
- YieldingWaitStrategy策略：这个策略用于低延时的场合。消费者线程会不断循环监控缓冲区变化，在循环内部使用Thread.yield()让出CPU给别的线程执行时间。如果需要一个高性能的系统，并且对延时比较有严格的要求，可以考虑这种策略。
- BusySpinWaitStrategy策略: 采用死循环，消费者线程会尽最大努力监控缓冲区的变化。对延时非常苛刻的场景使用，cpu核数必须大于消费者线程数量。推荐在线程绑定到固定的CPU的场景下使用
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
Disruptor的依赖信息
<dependency>
<groupId>com.lmax</groupId>
<artifactId>disruptor</artifactId>
<version>3.4.2</version>
</dependency>
Disruptor的使用方式：单个生产者
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.YieldingWaitStrategy;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import lombok.Data;
public class DisruptorTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建disruptor-单生产者
Disruptor<DisruptorTestEvent> disruptor = new Disruptor<>(new DisruptorTestFactory(), 1024 * 1024,
Executors.defaultThreadFactory(), ProducerType.SINGLE, // 单生产者
new YieldingWaitStrategy() // 等待策略
);
// 设置消费者用于处理RingBuffer的事件
disruptor.handleEventsWith(new DisruptorTestEventHandler());
// 多消费者模式：重复性消费
// disruptor.handleEventsWith(new DisruptorTestEventHandler2());
// 消费者开启
disruptor.start();
// 创建ringbuffer容器
RingBuffer<DisruptorTestEvent> ringBuffer = disruptor.getRingBuffer();
// 创建生产者
DisruptorTestProducer eventProducer = new DisruptorTestProducer(ringBuffer);
// 发送消息
for (int i = 0; i < 100; i++) {
eventProducer.onData(i, "zhangwei" + i);
}
disruptor.shutdown();
}
}
/**
* 消息载体类
*/
@Data
class DisruptorTestEvent {
private long value;
private String name;
}
/**
* 定义事件的工厂
*/
class DisruptorTestFactory implements EventFactory<DisruptorTestEvent> {
@Override
public DisruptorTestEvent newInstance() {
return new DisruptorTestEvent();
}
}
/**
* 消息（事件）生产者
*/
class DisruptorTestProducer {
// 事件队列
private RingBuffer<DisruptorTestEvent> ringBuffer;
// 构造方法
public DisruptorTestProducer(RingBuffer<DisruptorTestEvent> ringBuffer) {
this.ringBuffer = ringBuffer;
}
/**
* 一个生产的方法
*/
public void onData(long value, String name) {
// 获取事件队列 的下一个槽
long sequence = ringBuffer.next();
try {
// 获取消息（事件）
DisruptorTestEvent disruptorTestEvent = ringBuffer.get(sequence);
// 写入消息数据
disruptorTestEvent.setValue(value);
disruptorTestEvent.setName(name);
} catch (Exception e) {
// TODO 异常处理
e.printStackTrace();
} finally {
System.out.println("生产者发送数据value:" + value + ",name:" + name);
// 发布事件
ringBuffer.publish(sequence);
}
}
}
/**
* 消息（事件）消费者
*/
class DisruptorTestEventHandler implements EventHandler<DisruptorTestEvent> {
@Override
public void onEvent(DisruptorTestEvent event, long sequence, boolean endOfBatch) throws Exception {
// TODO 消费逻辑
System.out.println("消费者获取数据value:" + event.getValue() + ",name:" + event.getName());
}
}
/**
* 消息（事件）消费者，第二个
*/
class DisruptorTestEventHandler2 implements EventHandler<DisruptorTestEvent> {
@Override
public void onEvent(DisruptorTestEvent event, long sequence, boolean endOfBatch) throws Exception {
// TODO 消费逻辑
System.out.println("消费者2获取数据value:" + event.getValue() + ",name:" + event.getName());
}
}
Disruptor的使用方式：多个生产者
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import com.lmax.disruptor.EventFactory;
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.RingBuffer;
import com.lmax.disruptor.YieldingWaitStrategy;
import com.lmax.disruptor.dsl.Disruptor;
import com.lmax.disruptor.dsl.ProducerType;
import lombok.Data;
public class DisruptorTest {
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建disruptor-多生产者
Disruptor<DisruptorTestEvent> disruptor = new Disruptor<>(new DisruptorTestFactory(), 1024 * 1024,
Executors.defaultThreadFactory(), ProducerType.MULTI, // 多生产者
new YieldingWaitStrategy() // 等待策略
);
// 设置消费者用于处理RingBuffer的事件
disruptor.handleEventsWith(new DisruptorTestEventHandler());
// 多消费者模式：重复性消费
// disruptor.handleEventsWith(new DisruptorTestEventHandler2());
// 消费者开启
disruptor.start();
// 创建ringbuffer容器
RingBuffer<DisruptorTestEvent> ringBuffer = disruptor.getRingBuffer();
// 创建生产者
new Thread(()->{
//创建生产者
DisruptorTestProducer disruptorTestProducer = new DisruptorTestProducer(ringBuffer);
// 发送消息
for(int i=0;i<100;i++){
disruptorTestProducer.onData(i,"zhang"+i);
}
},"producer1").start();
new Thread(()->{
//创建生产者
DisruptorTestProducer disruptorTestProducer = new DisruptorTestProducer(ringBuffer);
// 发送消息
for(int i=0;i<100;i++){
disruptorTestProducer.onData(i,"wei"+i);
}
},"producer2").start();
disruptor.shutdown();
}
}
/**
* 消息载体类
*/
@Data
class DisruptorTestEvent {
private long value;
private String name;
}
/**
* 定义事件的工厂
*/
class DisruptorTestFactory implements EventFactory<DisruptorTestEvent> {
@Override
public DisruptorTestEvent newInstance() {
return new DisruptorTestEvent();
}
}
/**
* 消息（事件）生产者
*/
class DisruptorTestProducer {
// 事件队列
private RingBuffer<DisruptorTestEvent> ringBuffer;
// 构造方法
public DisruptorTestProducer(RingBuffer<DisruptorTestEvent> ringBuffer) {
this.ringBuffer = ringBuffer;
}
/**
* 一个生产的方法
*/
public void onData(long value, String name) {
// 获取事件队列 的下一个槽
long sequence = ringBuffer.next();
try {
// 获取消息（事件）
DisruptorTestEvent disruptorTestEvent = ringBuffer.get(sequence);
// 写入消息数据
disruptorTestEvent.setValue(value);
disruptorTestEvent.setName(name);
} catch (Exception e) {
// TODO 异常处理
e.printStackTrace();
} finally {
System.out.println("生产者发送数据value:" + value + ",name:" + name);
// 发布事件
ringBuffer.publish(sequence);
}
}
}
/**
* 消息（事件）消费者
*/
class DisruptorTestEventHandler implements EventHandler<DisruptorTestEvent> {
@Override
public void onEvent(DisruptorTestEvent event, long sequence, boolean endOfBatch) throws Exception {
// TODO 消费逻辑
System.out.println("消费者获取数据value:" + event.getValue() + ",name:" + event.getName());
}
}
/**
* 消息（事件）消费者，第二个
*/
class DisruptorTestEventHandler2 implements EventHandler<DisruptorTestEvent> {
@Override
public void onEvent(DisruptorTestEvent event, long sequence, boolean endOfBatch) throws Exception {
// TODO 消费逻辑
System.out.println("消费者2获取数据value:" + event.getValue() + ",name:" + event.getName());
}
}
结束语
- 获取更多本文的前置知识文章，以及新的有价值的文章，让我们一起成为架构师！
- 关注公众号，可以让你对MySQL、并发编程、spring源码有深入的了解！
- 关注公众号，后续持续高效的学习JVM！
- 这个公众号，无广告！！！每日更新！！！
