并发编程：自定义并发类：自定义异步流（发布与订阅）

最新推荐文章于 2024-03-19 07:00:00 发布
转载 最新推荐文章于 2024-03-19 07:00:00 发布 · 238 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：https://blog.csdn.net/Bof_jangle/article/details/109128739?utm_medium=distribute.pc_blog_right_sidebar.none-task-blog-alirec-8.nonecase&depth_1-utm_source=distribute.pc_blog_right_sidebar.none-task-blog-alirec-8.nonecase
本文介绍了一个自定义的异步流实现，通过发布订阅模式管理消息的发布与接收过程。使用了发布者(Publisher)、订阅者(Consumer)、订阅(Subscription)等组件，并通过线程池来处理发布的消息。

并发编程：自定义并发类：自定义异步流（发布与订阅）

博风

目录

主要内容（参考编程流）

一、主程序

二、发布者(Publisher)

三、发布任务类（PublisherTask)

四、订阅实体（ConsumerData)

五、订阅者（消费者Consumer extends Subscriber）

六、订阅信息（Subscription）

七、元素信息（News）

八、执行结果

主要内容（参考编程流）

  • Flow.Publisher:发布者（提供一个方法来接收Subscriber，进行消息发布）
  • Flow.Subscriber:订阅者（提供4个方法，分别用于：订阅完毕时，出现异常时，新元素被请求时，发布者注册订阅者时。）
  • Flow.Subscription:订阅（提供发布者与消费者之间的订阅处理）

一、主程序

  1. 实现一个发布者(Publisher)，两个消费者(Consumer extends Subscriber)，让它们建立订阅关系。
  2. 创建元素（News)，由发布者进行发布操作（发布操作会创建独立的发布任务，由执行器执行。）

  3. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  4.  

  5. import java.util.Date;

  6. import java.util.concurrent.TimeUnit;

  7.  

  8. /**

  9. * 8.13、自定义异步流（发布与订阅）

  10. *

  11. * @author jangle

  12. * @email jangle@jangle.xyz

  13. * @time 2020年10月16日 下午3:19:33

  14. *

  15. */

  16. public class M {

  17.  

  18. public static void main(String[] args) {

  19. var publisher = new MyPublisher();

  20. var consumer1 = new Consumer("Consumer 1");

  21. var consumer2 = new Consumer("Consumer 2");

  22. publisher.subscribe(consumer1);

  23. publisher.subscribe(consumer2);

  24. System.out.println("M:start");

  25. var news = new News();

  26. news.setTitle("My first news");

  27. news.setContent("This is the content");

  28. news.setDate(new Date());

  29. publisher.publish(news);

  30. try {

  31. TimeUnit.SECONDS.sleep(1);

  32. } catch (InterruptedException e) {

  33. e.printStackTrace();

  34. }

  35. news = new News();

  36. news.setTitle("My second news");

  37. news.setContent("This is the content for second news");

  38. news.setDate(new Date());

  39. publisher.publish(news);

  40. System.out.println("M:end");

  41. }

  42.  

  43. }

二、发布者(Publisher)

发布者包含订阅者(Subscriber)和订阅信息（Subscription）结合的实体（ConsumerData订阅实体）对象列表。

发布者包含执行器（ThreadPoolExecutor)，发布者发布信息时，会将元素信息（News)和订阅实体构造成发布任务（PublisherTask），由执行器执行。

 

  1. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  2.  

  3. import java.util.concurrent.ConcurrentLinkedDeque;

  4. import java.util.concurrent.Executors;

  5. import java.util.concurrent.ThreadPoolExecutor;

  6. import java.util.concurrent.Flow.Publisher;

  7. import java.util.concurrent.Flow.Subscriber;

  8.  

  9. /**

  10. *

  11. * @author jangle

  12. * @email jangle@jangle.xyz

  13. * @time 2020年10月16日 下午4:16:54

  14. *

  15. */

  16. public class MyPublisher implements Publisher<News> {

  17.  

  18. private ConcurrentLinkedDeque<ConsumerData> consumers;

  19. private ThreadPoolExecutor executor;

  20.  

  21. public MyPublisher() {

  22. consumers = new ConcurrentLinkedDeque<ConsumerData>();

  23. executor = (ThreadPoolExecutor) Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

  24. }

  25.  

  26. @Override

  27. public void subscribe(Subscriber<? super News> subscriber) {

  28. ConsumerData consumerData = new ConsumerData();

  29. consumerData.setConsumer((Consumer) subscriber);

  30. var subscription = new MySubscription();

  31. consumerData.setSubscription(subscription);

  32. subscriber.onSubscribe(subscription);

  33. consumers.add(consumerData);

  34. }

  35.  

  36. /**

  37. * 发布元素（为每个订阅者创建一个线程并提交给执行器执行。

  38. * @param news

  39. */

  40. public void publish(News news) {

  41. consumers.forEach(consumerData -> {

  42. try {

  43. executor.execute(new PublisherTask(consumerData, news));

  44. } catch (Exception e) {

  45. consumerData.getConsumer().onError(e);

  46. }

  47. });

  48. }

  49.  

  50. }

三、发布任务类（PublisherTask)

 

  1. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  2.  

  3. /**

  4. * 发布任务类

  5. * @author jangle

  6. * @email jangle@jangle.xyz

  7. * @time 2020年10月16日 下午4:07:54

  8. *

  9. */

  10. public class PublisherTask implements Runnable {

  11.  

  12. private ConsumerData consumerData;

  13. private News news;

  14.  

  15. public PublisherTask(ConsumerData consumerData, News news) {

  16. super();

  17. this.consumerData = consumerData;

  18. this.news = news;

  19. }

  20.  

  21. @Override

  22. public void run() {

  23. MySubscription subscription = consumerData.getSubscription();

  24. if (!subscription.isCanceled() && subscription.getRequested() > 0) {

  25. consumerData.getConsumer().onNext(news);

  26. subscription.decreaseRequested();

  27. }

  28. }

  29.  

  30. }

四、订阅实体（ConsumerData)

 

  1. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  2.  

  3. /**

  4. * 订阅者信息实体

  5. * @author jangle

  6. * @email jangle@jangle.xyz

  7. * @time 2020年10月16日 下午4:03:35

  8. *

  9. */

  10. public class ConsumerData {

  11.  

  12. private Consumer consumer;

  13. private MySubscription subscription;

  14.  

  15. public Consumer getConsumer() {

  16. return consumer;

  17. }

  18.  

  19. public void setConsumer(Consumer consumer) {

  20. this.consumer = consumer;

  21. }

  22.  

  23. public MySubscription getSubscription() {

  24. return subscription;

  25. }

  26.  

  27. public void setSubscription(MySubscription subscription) {

  28. this.subscription = subscription;

  29. }

  30.  

  31. }

五、订阅者（消费者Consumer extends Subscriber）

 

  1. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  2.  

  3. import java.util.concurrent.Flow.Subscriber;

  4. import java.util.concurrent.Flow.Subscription;

  5.  

  6. /**

  7. * 订阅者（消费者）

  8. * @author jangle

  9. * @email jangle@jangle.xyz

  10. * @time 2020年10月16日 下午3:25:14

  11. *

  12. */

  13. public class Consumer implements Subscriber<News> {

  14.  

  15. private Subscription subscription;

  16.  

  17. private String name;

  18.  

  19. public Consumer(String name) {

  20. super();

  21. this.name = name;

  22. }

  23.  

  24. @Override

  25. public void onSubscribe(Subscription subscription) {

  26. this.subscription = subscription;

  27. subscription.request(1);

  28. System.out.println(Thread.currentThread().getName() + ":onSubscribe() ******");

  29. }

  30.  

  31. @Override

  32. public void onNext(News item) {

  33. System.out.println(Thread.currentThread().getName() + ":" + name + ":onNext() ******" + item);

  34. subscription.request(1);

  35.  

  36. }

  37.  

  38. @Override

  39. public void onError(Throwable throwable) {

  40. System.out.println(Thread.currentThread().getName() + ":onError() ******");

  41. }

  42.  

  43. @Override

  44. public void onComplete() {

  45. System.out.println(Thread.currentThread().getName() + ":onComplete() ******");

  46. }

  47.  

  48. }

六、订阅信息（Subscription）

 

  1. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  2.  

  3. import java.util.concurrent.Flow.Subscription;

  4.  

  5. /**

  6. * 订阅

  7. * @author jangle

  8. * @email jangle@jangle.xyz

  9. * @time 2020年10月16日 下午3:37:50

  10. *

  11. */

  12. public class MySubscription implements Subscription {

  13.  

  14. private boolean canceled = false;

  15.  

  16. private long requested = 0;

  17.  

  18. @Override

  19. public void request(long n) {

  20. requested += n;

  21. }

  22.  

  23. @Override

  24. public void cancel() {

  25. canceled = true;

  26. }

  27.  

  28. public boolean isCanceled() {

  29. return canceled;

  30. }

  31.  

  32. public long getRequested() {

  33. return requested;

  34. }

  35.  

  36. public void decreaseRequested() {

  37. requested--;

  38. }

  39.  

  40. }

七、元素信息（News）

 

  1. package xyz.jangle.thread.test.n8_xiii.asyncstream;

  2.  

  3. import java.util.Date;

  4.  

  5. /**

  6. * 元素类

  7. *

  8. * @author jangle

  9. * @email jangle@jangle.xyz

  10. * @time 2020年10月16日 下午3:23:03

  11. *

  12. */

  13. public class News {

  14.  

  15. private String title, content;

  16.  

  17. private Date date;

  18.  

  19. public String getTitle() {

  20. return title;

  21. }

  22.  

  23. public void setTitle(String title) {

  24. this.title = title;

  25. }

  26.  

  27. public String getContent() {

  28. return content;

  29. }

  30.  

  31. public void setContent(String content) {

  32. this.content = content;

  33. }

  34.  

  35. public Date getDate() {

  36. return date;

  37. }

  38.  

  39. public void setDate(Date date) {

  40. this.date = date;

  41. }

  42.  

  43. @Override

  44. public String toString() {

  45. return "News [title=" + title + ", content=" + content + ", date=" + date + "]";

  46. }

  47.  

  48. }

八、执行结果

 

  1. main:onSubscribe() ******

  2. main:onSubscribe() ******

  3. M:start

  4. pool-1-thread-1:Consumer 1:onNext() ******News [title=My first news, content=This is the content, date=Fri Oct 16 16:52:44 CST 2020]

  5. pool-1-thread-2:Consumer 2:onNext() ******News [title=My first news, content=This is the content, date=Fri Oct 16 16:52:44 CST 2020]

  6. M:end

  7. pool-1-thread-3:Consumer 1:onNext() ******News [title=My second news, content=This is the content for second news, date=Fri Oct 16 16:52:45 CST 2020]

  8. pool-1-thread-4:Consumer 2:onNext() ******News [title=My second news, content=This is the content for second news, date=Fri Oct 16 16:52:45 CST 2020]

 

并发编程模式（如生产者-消费者、任务分区、发布-订阅等）可以帮助我们更好地组织多线程代码，提高可维护性、性能和健壮性
最新发布
专注于前沿技术的探索与实践，热衷于从代码逻辑、架构设计到行业应用等多维度深挖技术本质。期待在技术之路上与你共同成长～
04-06 620
基于之前的并发编程模式优化代码，我将进一步聚焦于生产者-消费者模式，对其进行更深入的优化和细化，以提高加热控制逻辑的效率、可扩展性和可维护性。在加热控制场景中，生产者-消费者模式非常适合处理多个加热板的温度检查任务（生产者）生成状态数据，并由主线程或专用消费者任务处理这些状态（消费者）。基于之前的线程同步优化代码，我将进一步引入并发编程模式，以更结构化和可扩展的方式优化加热控制逻辑。并发编程模式（如生产者-消费者、任务分区、发布-订阅等）可以帮助我们更好地组织多线程代码，提高可维护性、性能和健壮性。
RocketMq
不以人人的意志为转义乃天道
11-18 320
第一步: 连接服务器,注入监听逻辑操作.监听即触发.连接监听分离.但是配合操作. 连接服务器必传参数 :消费组,地址,实例名称,主题==tag public class MyDefaultMQPushConsumer extends DefaultMQPushConsumer{ public MyDefaultMQPushConsumer(String consumerGrou...
Java并发包源码分析(JDK1.8)
03-22
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包(AbstractQueuedSynchronizer、ReentrantLock、ReentrantReadWriteLock、LockSupport等)，queue(ArrayBlockingQueue、ConcurrentLinkedDeque、DelayQueue、LinkedBlockingQueue等) ，AQS相关应用(CountDownLatch、CyclicBarrier、Semaphore等)，executor（ThreadPoolExecutor、ScheduledThreadPoolExecutor、FutureTask等），collection（ConcurrentHashMap、CopyOnWriteArrayList等），对每个类的核心源码进行详细分析，笔记详细，由浅入深，层层深入，带您剖析并发编程原理
RocketMQ——Consumer篇：启动过程
meilong_whpu的专栏
08-09 1万+
RocketMQ提供了两种消费模式，PUSH和PULL，大多数场景使用的是PUSH模式，这两种模式分别对应的是DefaultMQPushConsumer类和DefaultMQPullConsumer类。PUSH模式实际上在内部还是使用的PULL方式实现的，通过PULL不断地轮询Broker获取消息，当不存在新消息时，Broker会挂起PULL请求，直到有新消息产生才取消挂起，返回新消息。故此处主要讲
【5】线程池原理分析
热门推荐
19年的努力，并不是说说而已！
11-22 12万+
目录 知识点1：并发包 1、(计数器)CountDownLatch 2、(屏障)CyclicBarrier 3、(计数信号量)Semaphore （1）案例 4、并发队列 5、阻塞队列与非阻塞队 （1）ConcurrentLinkedDeque （2）BlockingQueue （3）ArrayBlockingQueue （4）LinkedBlockingQueue ...
SpringBoot2.0不容错过的新特性 WebFlux响应式编程【第4章】reactive stream 响应式流
Dreamlate_Spider的博客
01-15 988
4-1 初识Reactive Stream 概念 JDK9引入的一套标准，是一套基于发布订阅者模式数据处理的规范。FLOW API。 背压 backpress发布者和订阅者之间的互动，调节数据流量的作用，
并发编程：自定义并发类：12、自定义异步流（发布与订阅）
博风_刺耳的博客（网络记事本）
10-17 722
发布与订阅。
实现自定义异步流
西木空间
12-02 363
Java 9并发编程指南 目录 实现自定义异步流准备工作实现过程工作原理扩展学习更多关注 响应式流（http://www.reactive-streams.org/）提供了具有非阻塞压力的异步流处理机制。 响应式流基于以下三个要素： 信息发布者 多个信息订阅者 发布者与消费者之间的订阅 Java 9提供三个接口，Flow.Publisher、Flow.Subscriber和Flow.Subsc...
Java并发编程之ReactiveSteams
励志成为一名优秀的全能型软件开发工程师。
03-19 1731
在聊Reactive Steams之前，先了解一下Reactive Programming（反应式/响应式编程）。为了解决异步编程中出现的各种问题，程序员们提出了各种的思路去解决这些问题，这些解决问题的方式，方法，手段就可以叫做Reactive Programming。Reactive Programming是一种编程思想，类似面向对象，函数式编程。本质上是对数据流或某种变化做出的反应，这个变化什么时候触发是未知的，所以他是一种基于异步、回调的方式在处理问题。
线程池流程原理分析、并发队列ConcurrentLinkedDeque、BlockingQueue阻塞队列介绍以及合理配置线程池
qq_41854137的博客
12-09 649
线程池流程图：         线程池原理分析： 部分源码解读： public class ThreadPoolExecutor extends AbstractExecutorService {      /**      * Creates a new {@code ThreadPoolExecutor} with the given initial      * paramete...
java.util.concurrent下相关研究学习
诗和远方，任重道远
06-16 869
写在前面 这个包是JDK 1.5之后，新增的，大概2009年，新增了 ，枚举定义，基本类型包装，注解，加强for循环，等新特性，提高了Java对并发编程的支持，也扩大了Java的市场，前景 一、lock 包下 这个包下共 10 个对象（接口、类） 如图， 下面简单介绍，这10 个对象 1.1、AbstractOwnableSynchronizer 可参考文章，介绍了AbstractOwnableSynchronizer和AbstractQueuedSynchronizer，链接 1.2、AbstractQ
Java-Concurrent 线程池ThreadPoolExecutor使用
weihao_的博客
08-23 302
      在高并发场景下，如果每一个请求或人物都开启一个线程，系统要不断的进行线程的创建、销毁，会消耗大量的系统性能，而线程的数量到达一个临界值时，系统会受到进一步更大的影响，这时候就需要用到线程池。     ThreadPoolExecutor线程池的类关系     Executor的定义是An Object that executes submitted tasks，即接口的实现是...
Kafka源码深度解析－序列9 －Consumer －SubscriptionState内部结构分析
lppl010_的专栏
07-16 360
https://blog.csdn.net/chunlongyu/article/details/52806408   在前面讲了，KafkaConsumer的一个重要部件就是SubscriptionState，这个部件维护了Consumer的消费状态，本篇对其内部结构进行分析。 2种订阅策略 在第1篇讲过，consumer可以自己指定要消费哪个partition，而不是让consumer...
rocketmq问题汇总-一个consumerGroup只对应一个topic
MQCloud的专栏
02-14 9万+
1 同一个订阅组内不同Consumer实例订阅不同topic消费混乱问题调查 图1： 背景说明： 如图1左半部分，假设目前的关系如下： broker： 两个，broker_a和broker_b topic：两个，topic1和topic2，每个topic在每个broker上分为4个queue consumer：两个，consumer1和consumer2
RocketMQ之消费者启动与消费流程
m0_71777195的博客
07-13 1290
RocketMQ是由阿里巴巴开源的分布式消息中间件，支持顺序消息、定时消息、自定义过滤器、负载均衡、pull/push消息等功能。RocketMQ主要由 Producer、Broker、Consumer 、NameServer四部分组成，其中Producer 负责生产消息，Consumer 负责消费消息，Broker 负责存储消息。NameServer充当名字路由服务，整体架构图如下所示：本文基于Apache RocketMQ 最新版本主要讲述RocketMQ的消费者机制，分析其启动流程、pull/push
Rocketmq简介及核心概念详解(一)
凯耐的博客
03-31 7815
一、rocketmq简介 rocketmq是一款分布式、队列模型的消息中间件，由阿里巴巴研发借鉴参考了JMS规范MQ实习，更参考了优秀的开源消息中间件kafka,并结合阿里巴巴的实际业务需求，在天猫双十一的场景，实现业务消峰，分布式事务的优秀框架。 底层代码编写清晰优秀，采用Netty NIOl框架实现数据通信。 3.X版本弃用Zookeeper,内部使用更轻量级的NameServer进行网...
《RocketMq》六、Client－Consumer消费者详解
zxx的专栏
12-23 4万+
Consumer-集群Push模式-简介：0、背景介绍         Consumer主要用于向Broker请求Producer产生的消息，对其进行消费；对于RocketMQ，我们一定很好奇，如何实现分布式的Consumer消费，如何保证Consumer的顺序性，不重复性呢？ 存在的问题：1. 如果在集群模式中新增/减少 组(group) 消费者，可能会导致重复消费；原因是：假设新增消费者前，C...
java并发编程一一线程池原理分析(一)
若成风的博客
10-30 321
随着cpu核数越来越多，不可避免的利用多线程技术以充分利用其计算能力。所以，多线程技术是服务端开发人员必须掌握的技术。
发布订阅模式代码
kunge001的博客
01-04 575
日常记录，共同探讨
Java9 基于异步响应式流的发布-订阅框架
Lovnx
10-08 1万+
为响应式流(Reactive Streams)增加的发布-订阅(publisher-subscriber)框架、并发包CompletableFuture类的增强，等等。。 JEP266中为Java语言的并发性又引入许多新的方式：响应式流，一个为它而生互操作性更强的发布-订阅框架；并且为了Java9其他API而增强的 java.util.concurrent.CompletableFuture 类，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值