在一个公众号中遇到项目使用Disruptor做消息队列,对你没看错,不是Kafka也不是rabbitmq。Disruptor有个最大的优点就是快,还有一点它是开源的哦,之前完全没有听说过,下面做个简单的记录。
Disruptor介绍
Disruptor 是英国外汇交易公司LMAX开发的一个高性能队列,研发的初衷是解决内存队列的延迟问题(在性能测试中发现竟然与I/O操作处于同样的数量级)。
基于 Disruptor 开发的系统单线程能支撑每秒 600 万订单,2010 年在 QCon 演讲后,获得了业界关注。
Disruptor 是如何做到如此高性能的?
- 无锁设计:Disruptor采用了无锁的设计,减少了线程间的竞争和上下文切换,提高了并发处理的效率。
- 环形缓冲区:Disruptor内部采用环形缓冲区来存储数据,这种数据结构可以有效地利用CPU缓存,提高了数据读写的速度。
- 预分配内存:Disruptor在初始化时会预先分配一定数量的内存空间,避免了动态内存分配的开销,减少了垃圾回收的频率,提高了性能。
- 零拷贝:Disruptor通过使用直接内存(Direct Memory)和内存映射文件(Memory-mapped Files)等技术,实现了零拷贝,减少了数据在内存间的复制,提高了数据处理的效率。
- 异步处理:Disruptor支持异步处理模式,可以让多个消费者同时处理数据,提高了系统的并发能力和吞吐量。
从功能上来看,Disruptor 是实现了“队列”的功能,而且是一个有界队列。那么它的应用场景自然就是“生产者-消费者”模型的应用场合了。
Disruptor是LMAX在线交易平台的关键组成部分,LMAX平台使用该框架对订单处理速度能达到600万TPS,除金融领域之外,其他一般的应用中都可以用到Disruptor,它可以带来显著的性能提升。
其实Disruptor与其说是一个框架,不如说是一种设计思路,这个设计思路对于存在“并发、缓冲区、生产者—消费者模型、事务处理”这些元素的程序来说,Disruptor提出了一种大幅提升性能(TPS)的方案。
https://github.com/LMAX-Exchange/disruptor
disruptor 主页地址
Disruptor 概念
先先从了解 Disruptor 的核心概念开始,来了解它是如何运作的。下面介绍的概念模型从了解 Disruptor 的核心概念开始,来了解它是如何运作的。下面介绍的概念模型
1、Ring Buffer(环形缓冲区): 环形缓冲区是Disruptor内部用于存储数据的数据结构,是一种预分配的、固定大小的数组,其大小通常是2的幂次方。生产者向环形缓冲区中写入数据,消费者从中读取数据,数据在环形缓冲区中以环形的方式流动。
2、Sequence(序列): 序列是Disruptor中用于跟踪生产者和消费者之间的进度的对象。每个消费者都有一个序列,用于标识其已处理的最新数据的位置。序列是线程安全的,并且能够确保消费者之间不会重复处理相同的数据。
3、Event(事件): 事件是Disruptor中传递的数据单元,可以是任意类型的对象。生产者向环形缓冲区中写入事件,消费者从中读取事件并进行处理。
4、Sequence Barrier(序列屏障): 序列屏障用于协调生产者和消费者之间的操作。它负责确保消费者不会读取到尚未被生产者写入的数据,并且能够保证消费者之间的处理顺序。
5、Event Processor(事件处理器): 事件处理器是Disruptor中的消费者,负责处理从环形缓冲区中读取的事件。每个事件处理器都持有一个序列,用于标识其已处理的最新事件的位置。
- 注意:如果理解不了。可以往下看~
环形缓冲区
: 想象一下你在玩捉迷藏,孩子们在一个环形的花园里跑来跑去。这个花园就像是环形缓冲区,数据(比如消息)在这个花园里流动,生产者放入数据,消费者取出数据,就像孩子们在花园里奔跑一样。
序列
: 每个孩子都有一个计数器,用来记录他们找到的最新的藏汇位置。这个计数器就像是序列,每个消费者都有一个。这样就能确保每个孩子都知道自己找到了哪个位置,不会重复找。
事件
: 想象每个孩子手里都拿着一个小纸条,上面写着信息,比如“找到了!”或者“还没找到”。这些小纸条就是事件,它们在孩子们之间传递,代表着数据。
序列屏障
: 想象一道隔离的围栏,孩子们不能越过去,只能从中间的门进入。这个围栏就像是序列屏障,它确保孩子们按顺序进入,不会乱了阵脚。
事件处理器
: 每个孩子都是一个事件处理器,他们负责接收小纸条,然后根据上面的信息做出相应的动作,比如喊“我找到了!”或者“我还没找到”。这样就完成了一次事件处理。
代码案例
通过下面8个步骤,你就能将Disruptor Get回家啦:
1、添加pom依赖
<dependency>
<groupId>com.lmax</groupId>
<artifactId>disruptor</artifactId>
<version>3.4.4</version>
</dependency>
创建一个消息体:Model
/**
* 消息体
*/
@Data
public class MessageModel {
private String message;
}
3、构造EventFactory
public class HelloEventFactory implements EventFactory<MessageModel> {
@Override
public MessageModel newInstance() {
return new MessageModel();
}
}
4、构造EventHandler-消费者
@Slf4j
public class HelloEventHandler implements EventHandler<MessageModel> {
@Override
public void onEvent(MessageModel event, long sequence, boolean endOfBatch) {
try {
//这里停止1s是为了确定消费消息是异步的
Thread.sleep(1000);
log.info("消费者处理消息开始");
if (event != null) {
log.info("消费者消费的信息是:{}",event);
}
} catch (Exception e) {
log.info("消费者处理消息失败");
}
log.info("消费者处理消息结束");
}
}
5、构造BeanManager
/**
* 获取实例化对象
*/
@Component
public class BeanManager implements ApplicationContextAware {
private static ApplicationContext applicationContext = null;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public static ApplicationContext getApplicationContext() { return applicationContext; }
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
public static <T> T getBean(Class<T> clazz) {
return applicationContext.getBean(clazz);
}
}
6、构造MQManager
@Configuration
public class MQManager {
@Bean("messageModel")
public RingBuffer<MessageModel> messageModelRingBuffer() {
//定义用于事件处理的线程池, Disruptor通过java.util.concurrent.ExecutorSerivce提供的线程来触发consumer的事件处理
ExecutorService executor = Executors.newFixedThreadPool(2);
//指定事件工厂
HelloEventFactory factory = new HelloEventFactory();
//指定ringbuffer字节大小,必须为2的N次方(能将求模运算转为位运算提高效率),否则将影响效率
int bufferSize = 1024 * 256;
//单线程模式,获取额外的性能
Disruptor<MessageModel> disruptor = new Disruptor<>(factory, bufferSize, executor,
ProducerType.SINGLE, new BlockingWaitStrategy());
//设置事件业务处理器---消费者
disruptor.handleEventsWith(new HelloEventHandler());
// 启动disruptor线程
disruptor.start();
//获取ringbuffer环,用于接取生产者生产的事件
RingBuffer<MessageModel> ringBuffer = disruptor.getRingBuffer();
return ringBuffer;
}
}
7、构造Mqservice和实现类-生产者
public interface DisruptorMqService {
/**
* 消息
* @param message
*/
void sayHelloMq(String message);
}
@Slf4j
@Component
@Service
public class DisruptorMqServiceImpl implements DisruptorMqService {
@Autowired
private RingBuffer<MessageModel> messageModelRingBuffer;
@Override
public void sayHelloMq(String message) {
log.info("record the message: {}",message);
//获取下一个Event槽的下标
long sequence = messageModelRingBuffer.next();
try {
//给Event填充数据
MessageModel event = messageModelRingBuffer.get(sequence);
event.setMessage(message);
log.info("往消息队列中添加消息:{}", event);
} catch (Exception e) {
log.error("failed to add event to messageModelRingBuffer for : e = {},{}",e,e.getMessage());
} finally {
//发布Event,激活观察者去消费,将sequence传递给改消费者
//注意最后的publish方法必须放在finally中以确保必须得到调用;如果某个请求的sequence未被提交将会堵塞后续的发布操作或者其他的producer
messageModelRingBuffer.publish(sequence);
}
}
}
8、构造测试类及方法
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = DemoApplication.class)
public class DemoApplicationTests {
@Autowired
private DisruptorMqService disruptorMqService;
/**
* 项目内部使用Disruptor做消息队列
* @throws Exception
*/
@Test
public void sayHelloMqTest() throws Exception{
disruptorMqService.sayHelloMq("消息到了,Hello world!");
log.info("消息队列已发送完毕");
//这里停止2s是为了确定是处理消息是异步的
Thread.sleep(2000);
}
}
总结:
其实 生成者 -> 消费者 模式是很常见的,通过一些消息队列也可以轻松做到上述的效果。不同的地方在于,Disruptor 是在内存中以队列的方式去实现的,而且是无锁的。这也是 Disruptor 为什么高效的原因。