// 一号消费者
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);
}
}
- 上述代码有以下几处要注意:
-
重写父类的init方法,主要是实例化Disruptor的时候,多传入两个参数:ProducerType.MULTI表示生产类型是多生产者,BlockingWaitStrategy是等待策略,之前的代码中咱们没有传此参数时,默认的就是BlockingWaitStrategy
-
init方法中还执行了setProducer2方法,设置成员变量producer2
-
重写publishWithProducer2方法,调用成员变量producer2发表事件
-
重写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获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/b0cac09ed06b600445f6817f822c2567.jpeg)
最后
终极手撕架构师的学习笔记:分布式+微服务+开源框架+性能优化
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!
千的学费,着实压力不小。自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!**
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。[外链图片转存中…(img-HLiWJIXe-1713319863363)]
[外链图片转存中…(img-to27XRKl-1713319863364)]
[外链图片转存中…(img-zAuRWF05-1713319863364)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,真正体系化!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
如果你觉得这些内容对你有帮助,可以扫码获取!!(备注Java获取)
![img](https://i-blog.csdnimg.cn/blog_migrate/b0cac09ed06b600445f6817f822c2567.jpeg)
最后
终极手撕架构师的学习笔记:分布式+微服务+开源框架+性能优化
[外链图片转存中…(img-vfkg1TzM-1713319863364)]
《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取!