disruptor笔记之六：常见场景

// 一号消费者

MailEventHandler c1 = new MailEventHandler(eventCountPrinter);

// 二号消费者

MailEventHandler c2 = new MailEventHandler(eventCountPrinter);

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

disruptor.handleEventsWith(c1, c2);

}

@Override

public void publishWithProducer2(String value) throws Exception {

producer2.onData(value);

}

}

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

1. 重写父类的init方法，主要是实例化Disruptor的时候，多传入两个参数：ProducerType.MULTI表示生产类型是多生产者，BlockingWaitStrategy是等待策略，之前的代码中咱们没有传此参数时，默认的就是BlockingWaitStrategy

2. init方法中还执行了setProducer2方法，设置成员变量producer2

3. 重写publishWithProducer2方法，调用成员变量producer2发表事件

4. 重写disruptorOperate方法，里面设置了两个独立消费者

• 验证上述代码的方式依旧是单元测试，打开ConsumeModeServiceTest.java，新增以下代码，可见新增了两个线程同时执行发布事件的操作：

@Autowired

@Qualifier(“multiProducerService”)

ConsumeModeService multiProducerService;

@Test

public void testMultiProducerService() throws InterruptedException {

log.info(“start testMultiProducerService”);

CountDownLatch countDownLatch = new CountDownLatch(1);

// 两个生产者，每个生产100个事件，一共生产两百个事件

// 两个独立消费者，每人消费200个事件，因此一共消费400个事件

int expectEventCount = EVENT_COUNT*4;

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

multiProducerService.setCountDown(countDownLatch, expectEventCount);

// 启动一个线程，用第一个生产者生产事件

new Thread(() -> {

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

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

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

}

}).start();

// 再启动一个线程，用第二个生产者生产事件

new Thread(() -> {

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

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

try {

multiProducerService.publishWithProducer2(String.valueOf(i));

} catch (Exception e) {

e.printStackTrace();

}

}

}).start();

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

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

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

countDownLatch.await();

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

assertEquals(expectEventCount, multiProducerService.eventCount());

}

• 测试结果如下，测试通过，符合预期：

C1、C2独立消费，C3依赖C1和C2

• 逻辑图如下：

• 实现代码如下，非常简单，依赖关系用then即可实现：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import com.bolingcavalry.service.MailWorkHandler;

import com.bolingcavalry.service.SmsEventHandler;

import org.springframework.stereotype.Service;

@Service(“scene5”)

public class Scene5 extends ConsumeModeService {

@Override

protected void disruptorOperate() {

MailEventHandler c1 = new MailEventHandler(eventCountPrinter);

MailEventHandler c2 = new MailEventHandler(eventCountPrinter);

MailEventHandler c3 = new MailEventHandler(eventCountPrinter);

disruptor

// C1、C2独立消费

.handleEventsWith(c1, c2)

// C3依赖C1和C2

.then(c3);

}

}

• 单元测试代码：

@Autowired

@Qualifier(“scene5”)

Scene5 scene5;

@Test

public void testScene5 () throws InterruptedException {

log.info(“start testScene5”);

testConsumeModeService(scene5,

EVENT_COUNT,

// 三个独立消费者，一共消费300个事件

EVENT_COUNT * 3);

}

• 为了节省篇幅，测试结果就不贴了，要注意的是，每个事件都一定是C1和C2先消费过，才会被C3消费到；

C1独立消费，C2和C3也独立消费，但依赖C1，C4依赖C2和C3

• 逻辑图如下：

• 实现代码如下：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import org.springframework.stereotype.Service;

@Service(“scene6”)

public class Scene6 extends ConsumeModeService {

@Override

protected void disruptorOperate() {

MailEventHandler c1 = new MailEventHandler(eventCountPrinter);

MailEventHandler c2 = new MailEventHandler(eventCountPrinter);

MailEventHandler c3 = new MailEventHandler(eventCountPrinter);

MailEventHandler c4 = new MailEventHandler(eventCountPrinter);

disruptor

// C1

.handleEventsWith(c1)

// C2和C3也独立消费

.then(c2, c3)

// C4依赖C2和C3

.then(c4);

}

}

• 单元测试代码：

@Autowired

@Qualifier(“scene6”)

Scene6 scene6;

@Test

public void testScene6 () throws InterruptedException {

log.info(“start testScene6”);

testConsumeModeService(scene6,

EVENT_COUNT,

// 四个独立消费者，一共消费400个事件

EVENT_COUNT * 4);

}

C1和C2独立消费，C3和C4也是独立消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4

• 逻辑图如下：

• 实现代码如下：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import org.springframework.stereotype.Service;

@Service(“scene7”)

public class Scene7 extends ConsumeModeService {

@Override

protected void disruptorOperate() {

MailEventHandler c1 = new MailEventHandler(eventCountPrinter);

MailEventHandler c2 = new MailEventHandler(eventCountPrinter);

MailEventHandler c3 = new MailEventHandler(eventCountPrinter);

MailEventHandler c4 = new MailEventHandler(eventCountPrinter);

MailEventHandler c5 = new MailEventHandler(eventCountPrinter);

disruptor

// C1和C2独立消费

.handleEventsWith(c1, c2)

// C3和C4也是独立消费，但C3和C4都依赖C1和C2

.then(c3, c4)

// 然后C5依赖C3和C4

.then(c5);

}

}

• 单元测试代码：

@Autowired

@Qualifier(“scene7”)

Scene7 scene7;

@Test

public void testScene7 () throws InterruptedException {

log.info(“start testScene7”);

testConsumeModeService(scene7,

EVENT_COUNT,

// 五个独立消费者，一共消费500个事件

EVENT_COUNT * 5);

}

C1和C2共同消费，C3和C4也是共同消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4

• 逻辑图如下：

• 实现代码如下：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import com.bolingcavalry.service.MailWorkHandler;

import org.springframework.stereotype.Service;

/**

• @author will (zq2599@gmail.com)

• @version 1.0

• @description: C1和C2共同消费，C3和C4也是共同消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4

• @date 2021/5/23 11:05

*/

@Service(“scene8”)

public class Scene8 extends ConsumeModeService {

@Override

protected void disruptorOperate() {

MailWorkHandler c1 = new MailWorkHandler(eventCountPrinter);

MailWorkHandler c2 = new MailWorkHandler(eventCountPrinter);

MailWorkHandler c3 = new MailWorkHandler(eventCountPrinter);

MailWorkHandler c4 = new MailWorkHandler(eventCountPrinter);

MailWorkHandler c5 = new MailWorkHandler(eventCountPrinter);

disruptor

// C1和C2共同消费

.handleEventsWithWorkerPool(c1, c2)

// C3和C4也是独立消费，但C3和C4都依赖C1和C2

.thenHandleEventsWithWorkerPool(c3, c4)

// 然后C5依赖C3和C4

.thenHandleEventsWithWorkerPool(c5);

}

}

• 单元测试代码：

@Autowired

@Qualifier(“scene8”)

Scene8 scene8;

@Test

public void testScene8 () throws InterruptedException {

log.info(“start testScene8”);

testConsumeModeService(scene8,

EVENT_COUNT,

// C1和C2共同消费，C3和C4共同消费，C5虽然只是一个，但也是共同消费模式,

// 也就是一共有三组消费者，所以一共消费300个事件

EVENT_COUNT * 3);

}

C1和C2共同消费，C3和C4独立消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4

• 逻辑图如下：

• 实现代码如下：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import com.bolingcavalry.service.MailWorkHandler;

import org.springframework.stereotype.Service;

@Service(“scene9”)

public class Scene9 extends ConsumeModeService {

@Override

protected void disruptorOperate() {

MailWorkHandler c1 = new MailWorkHandler(eventCountPrinter);

MailWorkHandler c2 = new MailWorkHandler(eventCountPrinter);

MailEventHandler c3 = new MailEventHandler(eventCountPrinter);

MailEventHandler c4 = new MailEventHandler(eventCountPrinter);

MailEventHandler c5 = new MailEventHandler(eventCountPrinter);

disruptor

// C1和C2共同消费

.handleEventsWithWorkerPool(c1, c2)

// C3和C4独立消费，但C3和C4都依赖C1和C2

.then(c3, c4)

// 然后C5依赖C3和C4

.then(c5);

}

}

• 单元测试代码：

@Autowired

@Qualifier(“scene9”)

Scene9 scene9;

@Test

public void testScene9 () throws InterruptedException {

log.info(“start testScene9”);

testConsumeModeService(scene9,

EVENT_COUNT,

// C1和C2共同消费（100个事件），

// C3和C4独立消费（200个事件）,

// C5独立消费（100个事件）,

// 所以一共消费400个事件

EVENT_COUNT * 4);

}

C1和C2独立消费，C3和C4是共同消费，但C3和C4都依赖C1和C2，然后C5依赖C3和C4

• 逻辑图如下：

• 实现代码如下：

package com.bolingcavalry.service.impl;

import com.bolingcavalry.service.ConsumeModeService;

import com.bolingcavalry.service.MailEventHandler;

import com.bolingcavalry.service.MailWorkHandler;

import org.springframework.stereotype.Service;

@Service(“scene10”)

public class Scene10 extends ConsumeModeService {

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

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

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

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

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

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

最后

终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

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

[外链图片转存中…(img-to27XRKl-1713319863364)]

[外链图片转存中…(img-zAuRWF05-1713319863364)]

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

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

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

最后

终极手撕架构师的学习笔记：分布式+微服务+开源框架+性能优化

[外链图片转存中…(img-vfkg1TzM-1713319863364)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！