disruptor笔记之五：事件消费实战

于 2024-04-03 06:30:52 发布
阅读量863 收藏 14
点赞数 30
分类专栏： 程序员 文章标签： 笔记 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ehehhahs/article/details/137319690
版权

import lombok.Setter;

import org.springframework.scheduling.concurrent.CustomizableThreadFactory;

import javax.annotation.PostConstruct;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.atomic.AtomicLong;

import java.util.function.Consumer;

public abstract class ConsumeModeService {

/**

  • 独立消费者数量

*/

public static final int INDEPENDENT_CONSUMER_NUM = 2;

/**

  • 环形缓冲区大小

*/

protected int BUFFER_SIZE = 16;

protected Disruptor disruptor;

@Setter

private OrderEventProducer producer;

/**

  • 统计消息总数

*/

protected final AtomicLong eventCount = new AtomicLong();

/**

  • 这是辅助测试用的，

  • 测试的时候，完成事件发布后，测试主线程就用这个countDownLatch开始等待，

  • 在消费到指定的数量(countDownLatchGate)后，消费线程执行countDownLatch的countDown方法，

  • 这样测试主线程就可以结束等待了

*/

private CountDownLatch countDownLatch;

/**

  • 这是辅助测试用的，

  • 测试的时候，完成事件发布后，测试主线程就用这个countDownLatch开始等待，

  • 在消费到指定的数量(countDownLatchGate)后，消费线程执行countDownLatch的countDown方法，

  • 这样测试主线程就可以结束等待了

*/

private int countDownLatchGate;

/**

  • 准备一个匿名类，传给disruptor的事件处理类，

  • 这样每次处理事件时，都会将已经处理事件的总数打印出来

*/

protected Consumer<?> eventCountPrinter = new Consumer() {

@Override

public void accept(Object o) {

long count = eventCount.incrementAndGet();

/**

  • 这是辅助测试用的，

  • 测试的时候，完成事件发布后，测试主线程就用这个countDownLatch开始等待，

  • 在消费到指定的数量(countDownLatchGate)后，消费线程执行countDownLatch的countDown方法，

  • 这样测试主线程就可以结束等待了

*/

if (null!=countDownLatch && count>=countDownLatchGate) {

countDownLatch.countDown();

}

}

};

/**

  • 发布一个事件

  • @param value

  • @return

*/

public void publish(String value) {

producer.onData(value);

}

/**

  • 返回已经处理的任务总数

  • @return

*/

public long eventCount() {

return eventCount.get();

}

/**

  • 这是辅助测试用的，

  • 测试的时候，完成事件发布后，测试主线程就用这个countDownLatch开始等待，

  • 在消费到指定的数量(countDownLatchGate)后，消费线程执行countDownLatch的countDown方法，

  • 这样测试主线程就可以结束等待了

  • @param countDownLatch

  • @param countDownLatchGate

*/

public void setCountDown(CountDownLatch countDownLatch, int countDownLatchGate) {

this.countDownLatch = countDownLatch;

this.countDownLatchGate = countDownLatchGate;

}

/**

  • 留给子类实现具体的事件消费逻辑

*/

protected abstract void disruptorOperate();

@PostConstruct

private void init() {

// 实例化

disruptor = new Disruptor<>(new OrderEventFactory(),

BUFFER_SIZE,

new CustomizableThreadFactory(“event-handler-”));

// 留给子类实现具体的事件消费逻辑

disruptorOperate();

// 启动

disruptor.start();

// 生产者

setProducer(new OrderEventProducer(disruptor.getRingBuffer()));

}

}

  • 上述代码，有以下几处需要注意：

  1. init方法是spring bean实例化后要执行的方法，这里面实例化Disruptor，还启动了消费线程，并且实例化了事件生产者，具体的事件消费逻辑，由子类在disruptorOperate方法中实现；

  2. eventCountPrinter是个匿名类实例，传给事件消费的handler后，每消费一个事件都会执行一次eventCountPrinter.accept方法，这样就把消费事件的总数准确的保存在eventCount变量中了；

  3. countDownLatch和countDownLatchGate是为了辅助单元测试而准备的，测试的时候，完成事件发布后，测试主线程就用这个countDownLatch开始等待，在消费到指定的数量(countDownLatchGate)后，消费线程执行countDownLatch的countDown方法，这样测试主线程就可以结束等待了

  • 至此，公用代码就写完了，可见抽象父类已经做好了大部分事情，咱们的子类可以聚焦事件消费的逻辑编排了，开始挨个实现那三个场景；

100个订单，短信和邮件系统独立消费

  • 两个消费者独立消费的逻辑非常简单，就一行代码，调用handleEventsWith方法把所有消费者实例传进去，就完事了：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import com.bolingcavalry.service.SmsEventHandler;

import org.springframework.stereotype.Service;

@Service(“independentModeService”)

public class IndependentModeServiceImpl extends ConsumeModeService {

@Override

protected void disruptorOperate() {

// 调用handleEventsWith，表示创建的多个消费者，每个都是独立消费的

// 这里创建两个消费者，一个是短信的，一个是邮件的

disruptor.handleEventsWith(new SmsEventHandler(eventCountPrinter), new MailEventHandler(eventCountPrinter));

}

}

  • 单元测试代码如下，要注意的地方是发布完100事件后，调用countDownLatch.await()方法开始等待，直到消费者线程调用countDownLatch.countDown()方法解除等待，还有就是预期的消费消息总数等于200：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import lombok.extern.slf4j.Slf4j;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringRunner;

import java.util.concurrent.CountDownLatch;

import static org.junit.Assert.assertEquals;

@RunWith(SpringRunner.class)

@SpringBootTest

@Slf4j

public class ConsumeModeServiceTest {

@Autowired

@Qualifier(“independentModeService”)

ConsumeModeService independentModeService;

/**

  • 测试时生产的消息数量

*/

private static final int EVENT_COUNT = 100;

private void testConsumeModeService(ConsumeModeService service, int eventCount, int expectEventCount) throws InterruptedException {

CountDownLatch countDownLatch = new CountDownLatch(1);

// 告诉service，等消费到expectEventCount个消息时，就执行countDownLatch.countDown方法

service.setCountDown(countDownLatch, expectEventCount);

for(int i=0;i<eventCount;i++) {

log.info(“publich {}”, i);

service.publish(String.valueOf(i));

}

// 当前线程开始等待，前面的service.setCountDown方法已经告诉过service，

// 等消费到expectEventCount个消息时，就执行countDownLatch.countDown方法

// 千万注意，要调用await方法，而不是wait方法！

countDownLatch.await();

// 消费的事件总数应该等于发布的事件数

assertEquals(expectEventCount, service.eventCount());

}

@Test

public void testIndependentModeService() throws InterruptedException {

log.info(“start testIndependentModeService”);

testConsumeModeService(independentModeService,

EVENT_COUNT,

EVENT_COUNT * ConsumeModeService.INDEPENDENT_CONSUMER_NUM);

}

}

  • 单元测试执行结果如下，符合预期：

在这里插入图片描述

100个订单，邮件系统的两个邮件服务器共同消费

  • 两个消费者共同消费的代码也很简单，调用handleEventsWithWorkerPool方法即可，把共同消费的MailWorkHandler实例作为参数传入：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailWorkHandler;

import org.springframework.stereotype.Service;

@Service(“shareModeService”)

public class ShareModeServiceImpl extends ConsumeModeService {

@Override

protected void disruptorOperate() {

// mailWorkHandler1模拟一号邮件服务器

MailWorkHandler mailWorkHandler1 = new MailWorkHandler(eventCountPrinter);

// mailWorkHandler2模拟一号邮件服务器

MailWorkHandler mailWorkHandler2 = new MailWorkHandler(eventCountPrinter);

// 调用handleEventsWithWorkerPool，表示创建的多个消费者以共同消费的模式消费

disruptor.handleEventsWithWorkerPool(mailWorkHandler1, mailWorkHandler2);

}

}

  • 单元测试是在ConsumeModeServiceTest.java中添加如下代码，注意由于是共同消费，因此预期的消费事件数等于消息数，都是100：

@Autowired

@Qualifier(“shareModeService”)

ConsumeModeService shareModeService;

@Test

public void testShareModeService() throws InterruptedException {

log.info(“start testShareModeService”);

testConsumeModeService(shareModeService, EVENT_COUNT, EVENT_COUNT);

}

  • 执行单元测试，结果如下图：

在这里插入图片描述

100个订单，短信系统独立消费，与此同时，两个邮件服务器共同消费

  • 最后一个场景，依旧很简单，handleEventsWith调用一次，再调用一次handleEventsWithWorkerPool即可：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailWorkHandler;

import com.bolingcavalry.service.SmsEventHandler;

import org.springframework.stereotype.Service;

@Service(“independentAndShareModeService”)

public class IndependentAndShareModeServiceImpl extends ConsumeModeService {

@Override

protected void disruptorOperate() {

// 调用handleEventsWith，表示创建的多个消费者，每个都是独立消费的

// 这里创建一个消费者，短信服务

disruptor.handleEventsWith(new SmsEventHandler(eventCountPrinter));

// mailWorkHandler1模拟一号邮件服务器

MailWorkHandler mailWorkHandler1 = new MailWorkHandler(eventCountPrinter);

// mailWorkHandler2模拟一号邮件服务器

MailWorkHandler mailWorkHandler2 = new MailWorkHandler(eventCountPrinter);

// 调用handleEventsWithWorkerPool，表示创建的多个消费者以共同消费的模式消费

disruptor.handleEventsWithWorkerPool(mailWorkHandler1, mailWorkHandler2);
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

Kafka实战笔记

关于这份笔记，为了不影响大家的阅读体验，我只能在文章中展示部分的章节内容和核心截图

image.png

  • Kafka入门
  • 为什么选择Kafka
  • Karka的安装、管理和配置

image.png

  • Kafka的集群
  • 第一个Kafka程序
  • image.png

afka的生产者

image.png

  • Kafka的消费者
  • 深入理解Kafka
  • 可靠的数据传递

image.png

image.png

  • Spring和Kalka的整合
  • Sprinboot和Kafka的整合
  • Kafka实战之削峰填谷
  • 数据管道和流式处理(了解即可)

image.png

  • Kafka实战之削峰填谷

image.png

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！
…(img-kWqxnxOi-1712097038771)]

  • Kafka的集群
  • 第一个Kafka程序
  • [外链图片转存中…(img-WjuGn0YM-1712097038771)]

afka的生产者

[外链图片转存中…(img-KHuUgDuR-1712097038771)]

  • Kafka的消费者
  • 深入理解Kafka
  • 可靠的数据传递

[外链图片转存中…(img-clTUfNs1-1712097038772)]

[外链图片转存中…(img-x2SCfTvF-1712097038772)]

  • Spring和Kalka的整合
  • Sprinboot和Kafka的整合
  • Kafka实战之削峰填谷
  • 数据管道和流式处理(了解即可)

[外链图片转存中…(img-vCmqTUlU-1712097038772)]

  • Kafka实战之削峰填谷

[外链图片转存中…(img-7TdbY3wc-1712097038772)]

《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》，点击传送门即可获取！

葙湘镶芗
关注
  • 30
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
disrupter java_Disruptor (5) - 使用的不同场景
weixin_36410567的博客
03-05 597
handleEventsWith & handleEventsWithWorkerPool在disruptor框架调用start方法之前，往往需要将消息的消费者指定给disruptor框架。disruptor.handleEventsWith(EventHandler... handlers)，将多个EventHandler的实现类传入方法，封装成一个EventHandlerGroup。d...
Disruptor框架中生产者、消费者的各种复杂依赖场景下的使用总结
weixin_30645617的博客
03-11 970
版权声明：原创作品，谢绝转载！否则将追究法律责任。 Disruptor是一个优秀的并发框架，可以实现单个或多个生产者生产消息，单个或多个消费者消息，且消费者之间可以存在消费消息的依赖关系。网上其他博客往往仅针对框架的一部分使用示例进行了介绍，对于某些场景下介绍并不完全：如多生产者间复杂的依赖关系的使用编码。 本文尽可能对Disruptor的所有使用场景进行总结，如有不全之处欢迎指出，请谅解。...
Disruptor的事件处理机制
不甘平庸的人
08-12 945
单生产者，多消费者模式。消费者1、2不重复消费消息，消费者3、4消费消费者1或2消费过的消息，且独立重复消费。消费者5消费消费者3、4均消费过的消息。单生产者，多消费者模式。消费者1、2独立消费每一条消息，消费者3、4不重复消费消费者1、2均处理过的消息，消费者5消费消费者3或4消费过的消息。消费者之间存在消费顺序，相当于在各个EventHandlerGroup之间进行级联，形成依赖关系。多消费者之间不重复消费，且不同的消费者WorkPool之间存在依赖关系。多生产者，单消费者版本。...
Java多线程 - Disruptor2
weixin_42073629的博客
10-03 261
Disruptor框架中生产者、消费者的各种复杂依赖场景下的使用总结 具体而言，它可以解决如下方面： - 并行计算实现； - 串行依次执行； - 菱形方式执行； - 链式并行计算。 并且基于以上情况，每种类型的消费者都可以池化，默认初始化多个同一类型的消费者实例，并行处理，提高系统吞吐量。 本样例是一个生产者生产一个Long类型的数值，消费者对该数值进行处理的操作。本样例对以上各种情况的实现只...
高性能并发框架Disruptor
chengbinbbs的专栏
10-09 494
一、Disruptor是什么 Disruptor是一个开源的并发框架，能够在无锁的情况下实现网络的Queue并发操作。 Disruptor是一个高性能的异步处理框架，或者可以认为是最快的消息框架（轻量级JMS），也可以认为是一个观察者模式的实现，或者事件监听模式的实现。 二、Disruptor核心概念 RingBuffer： 被看做Disruptor最主要组件，然而从3.0开始RingBuf...
disruptor笔记之四：事件消费知识点小结（csdn）————程序.pdf
12-01
disruptor笔记之四：事件消费知识点小结（csdn）————程序
disruptor-kafka-consumer:基于React流的卡夫卡消费者
04-30
卡夫卡消费者的破坏者演示如何在Kafka 0.9 Consumer上使用LMAX Disruptor 好处->一旦先前的使用者完全处理完消息，便可以使用序列屏障来提交消息。想象力是极限。如果环形缓冲区可以容纳在L3缓存中，则处理速度会更...
disruptor 多个消费者
04-05
4. **工作窃取算法**：在Disruptor中，如果一个消费者处理得更快，它可以“窃取”其他消费者未处理的事件，前提是这些事件尚未被其他消费者处理。这种设计提高了处理器利用率，防止了资源浪费。 5. **中断与唤醒...
disruptor:Disruptor BlockingQueue
05-29
Conversant ConcurrentQueue、Disruptor BlockingQueue 和 ConcurrentStack Disruptor是Java中性能最高的线程内传输机制。 Conversant Disruptor 是这种环形缓冲区中性能最高的实现，因为它几乎没有开销，并且采用了...
Disruptor-cpp：LMAX Disruptor到C ++的端口
02-01
Disruptor-cpp 总览 Disruptor-cpp是功能齐全的C ++端口。 实现java Disruptor v3.3.7中可用的所有功能。 建造 编译器 Clang 3.8或更高版本 GCC 5.0或更高版本 Microsoft Visual C ++ 2015或更高版本 Linux 必须在...
springboot整合disruptor（线程工厂）
最新发布
weixin_42405132的博客
03-24 1490
生产者往RingBuffer中放数据，disruptor把数据推给消费者
Disruptor
一颗旋转的螺丝钉
05-04 2392
参考文章： https://tech.meituan.com/2016/11/18/disruptor.html https://www.cnblogs.com/pku-liuqiang/p/8544700.html 定义Disruptor @Component @Slf4j public class DisruptorUtil { private static int bufferSize ...
disruptor 史上最全之3： 8大使用场景详细图解
架构师尼恩
10-05 4247
本文简绍 disruptor的 8大使用场景
高性能的异步处理框架Disruptor(五)——Disruptor2.0的应用
不能说的秘密的博客
10-18 1071
前文讲了那么多理论，原理。现在通过实际的代码，来看看Disruptor2.0的几种实际应用代码。 Event事件定义： /** * Event，RingBuffer的数据 * @author wangxi * @date 2019-10-16 16:31 */ @Slf4j public class DisruptorEvent implements Serializable { ...
从海量数值中找出最大的N个元素的算法实现
Coding Road
06-11 634
本例要求 一个文件中存有海量（大小超过40W）Long类型数值，每个数值一行，且各不相同 堆内存大小4M 以最快方式找出海量数值中最大的前100个数值，限时2s以内 解题思路 首先，肯定不能将海量数据压入TreeSet中进行排序，这样会造成堆内存溢出。 首先想到的是，采用TreeSet，维护一个小顶堆，堆里只有k个元素，从而保证堆内存不溢出。然后将后面的元素压入堆中，基于TreeSet...
高吞吐高性能异步消息处理系统（二）
八荒六合唯我独尊
06-11 298
=========================生产者线程从redis queue中读取消息，加入ringBuffer==========================================消息者线程从ringBuffer中消费消息，交由具体的eventHandler处理=========事件类package com.qb.loan.disruptor; public class ...
Disruptor并行，串行，菱形计算例子
零落的尘土
09-09 727
public class MainDisruptor { public static void main(String[] args) throws InterruptedException { int bufferSize = 1024*1024;//环形队列长度，必须是2的N次方 EventFactory<LongEvent> eventFact...
并发编程之Disruptor框架介绍和高阶运用
击水三千里的专栏
12-10 4800
1. Disruptor是什么 1.1 技术背景 LMAX是在英国注册并受到FCA监管（监管号码为509778）的外汇黄金交易所, LMAX架构是LMAX内部研发并应用到交易系统的一种技术。它之所以引起人们的关注,是因为它是一个非常高性能系统，这个系统是建立在JVM平台上，核心是一个业务逻辑处理器，官方号称它能够在一个线程里每秒处理6百万订单. 一个仅仅部署在4台服务器上的服务，每秒...
《Java高并发程序设计》总结--5. 并行模式与算法
hehuanshu347的博客
03-14 1719
1. 探讨单例模式 它是一种对象创建模式，用于产生一个对象的具体实例,确保系统中一个类只有一个实例。这样带来的好处主要有两点：  1. 对于频繁使用的对象，可以省略new操作花费的时间，这样对于那些重量级对象而言，可以节省非常可观的一笔系统开销。 2. 由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短GC停顿时间。 下面给出了一个单例的实现，这个实习生非常
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值