jdk9 响应式流

最新推荐文章于 2024-07-05 11:45:36 发布
最新推荐文章于 2024-07-05 11:45:36 发布
阅读量564 收藏 2
点赞数 2
分类专栏： # 响应式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/it_freshman/article/details/105620937
版权

引用： https://www.cnblogs.com/IcanFixIt/p/7245377.html
引用： https://juejin.im/post/5e59bc266fb9a07ca90c2ecb

什么是流

流是由生产者生产并由一个或多个消费者消费的元素（item）的序列。

这种生产者-消费者模型也被称为source/sink模型或发布者-订阅者（publisher-subscriber ）模型。

流的处理机制

有几种流处理机制，其中pull模型和push模型是最常见的。

  • 在push模型中，发布者将元素推送给订阅者。
  • 在pull模式中，订阅者主动拉取发布者生产的元素。

发布者和订阅者都以同样的速率工作，这是一个理想的情况，这些模式非常有效。 但是，如果他们不按同样的速率工作，这种情况下涉及的问题以及对应的解决办法。
当发布者比订阅者快的时候

  • 一种解决方案是：后者必须有一个无边界缓冲区来保存快速传入的元素，或者它必须丢弃它无法处理的元素。
  • 另一个解决方案是：使用一种称为背压（backpressure ）的策略。

背压(back pressure)
 如果生产者发出的信息比消费者能够处理消息最大量还要多，消费者可能会被迫一直在抓消息，耗费越来越多的资源，埋下潜在的崩溃风险。为了防止这一点，需要有一种机制使消费者可以通知生产者，降低消息的生成速度。生产者可以采用多种策略来实现这一要求，这种机制称为背压。
 简单来说：

  • 背压指的发布者和订阅者之间的互动
  • 订阅者可以告诉发布者自己需要多少数据，可以调节数据流量，不会导致发布者发布数据过多导致数据浪费或压垮订阅者

响应式流

Reactive Stream 概念
 Reactive Stream (响应式流/反应流) 是JDK9引入的一套标准，是一套基于发布/订阅模式的数据处理规范。响应式流从2013年开始，作为提供非阻塞背压的异步流处理标准的倡议。它旨在解决处理元素流的问题——如何将元素流从发布者传递到订阅者，而不需要发布者阻塞，或订阅者有无限制的缓冲区或丢弃。
 更确切地说，Reactive流目的是“找到最小的一组接口，方法和协议，用来描述必要的操作和实体以实现这样的目标：以非阻塞背压方式实现数据的异步流”。

反应式流 (Reactive Stream) 规范诞生

Subscription 接口定义了连接发布者和订阅者的方法
Publisher<T> 接口定义了发布者的方法
Subscriber<T> 接口定义了订阅者的方法
Processor<T,R> 接口定义了处理器

Reactive Stream 规范诞生后，RxJava 从 RxJava 2 开始实现 Reactive Stream 规范 ， 同时 Spring提供的Reactor 框架（WebFlux的基础） 等也相继实现了 Reactive Stream 规范

订阅者和发布者之间的交互
[图片]

  • 发布者（publisher）是潜在无限数量的有序元素的生产者。 它根据收到的要求向当前订阅者发布（或发送）元素。

  • 订阅者（subscriber）从发布者那里订阅并接收元素。

    • 发布者向订阅者发送订阅令牌（subscription token）。
    • 订阅者使用订阅令牌从发布者哪里请求多个元素。
    • 当元素准备就绪时，发布者向订阅者发送多个或更少的元素。
    • 订阅者使用订阅令牌来调整请求数据的个数

  • 订阅（subscription）表示订阅者订阅的一个发布者的令牌。 当订阅请求成功时，发布者将其传递给订阅者。 订阅者使用订阅令牌与发布者进行交互，例如请求更多的元素(request)或取消订阅(cancel)。
    -处理者（processor）充当订阅者和发布者的处理阶段。 Processor接口继承了Publisher和Subscriber接口。 它用于转换发布-订阅者管道中的元素。 Processor<T,R> 订阅类型T的数据元素，接收并转换为类型R的数据，并发布变换后的数据。 下图显示了处理者在发布者——订阅和管道中作为转换器的作用。 可以拥有多个处理者。
    在这里插入图片描述

JDK9 Flow API

JDK9中Reactive Stream的实现规范 通常被称为 Flow API ，通过java.util.concurrent.Flow 来实现响应式流.

APIs

//package java.util.concurrent;

public final class Flow {

    @FunctionalInterface
    public static interface Publisher<T> {       
     public void subscribe(Subscriber<? super T> subscriber);
    }

    public static interface Subscriber<T> {
       //发布者subscribe订阅者时触发， 发送subscription
        public void onSubscribe(Subscription subscription);
		
		//订阅者接收消息处理逻辑
        public void onNext(T item);
	   
        public void onError(Throwable throwable);
	
		//发布者 close时触发
        public void onComplete();
    }

 
    public static interface Subscription {
    	//订阅者向发布者请求数据
        public void request(long n);
        public void cancel();
    }
	
	//转换器 分别继承了 Subscriber和Publisher接口
    public static interface Processor<T,R> extends Subscriber<T>, Publisher<R> {
    }
	
	//默认缓冲池大小
  	static final int DEFAULT_BUFFER_SIZE = 256;
    public static int defaultBufferSize() {
        return DEFAULT_BUFFER_SIZE;
    }
}

demo1

private static void test01() throws InterruptedException {
        Random random = new Random();
        //1.自定义发布者， 发布数据类型为Integer
        //使用jdk9自带的SubmissionPublisher,它实现了Publisher接口
        SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();

        //2.定义订阅者
        Flow.Subscriber<Integer> subscriber = new Flow.Subscriber<Integer>() {
            private Flow.Subscription subscription;

            @Override
            public void onSubscribe(Flow.Subscription sb) {
                //建立订阅关系
                this.subscription = sb;

                //2. 请求数据 ----
                this.subscription.request(1);
            }

            @Override
            public void onNext(Integer item) {
                System.out.println("接收到数据：" + item);

                this.subscription.request(2);
                //已经达到了目标，调用cancel告诉发布者，不在接收数据
//                this.subscription.cancel();
            }

            @Override
            public void onError(Throwable throwable) {
                //出现异常
                throwable.printStackTrace();

                this.subscription.cancel();
            }

            @Override
            public void onComplete() {
                //在publisher.close();时触发..
                System.out.println("数据处理完了");
            }
        };

        // 3.发布者和订阅者 建立订阅关系
        publisher.subscribe(subscriber);

        //4.生产数据，并发布
        publisher.submit(100);
        publisher.submit(200);
        publisher.submit(300);
        publisher.submit(400);

        //5.结束后，关闭发布者
        publisher.close();

        Thread.currentThread().join(1000);
    }

demo2–Processor
Proceeor主要的作用是用具加工、处理发布者发布的消息。
下例：用来展示Processor过滤掉发布者生产的小于200的消息，并且对消息进行转换Integer --> String.
MyProcessor

static class MyProcessor extends SubmissionPublisher<String> implements Flow.Processor<Integer, String> {
        private Flow.Subscription subscription;
        @Override
        public void onSubscribe(Flow.Subscription sb) {
            //建立订阅关系
            this.subscription = sb;
            //2. 请求数据 ----
            this.subscription.request(1);
        }

        @Override
        public void onNext(Integer item) {
            System.out.println("processor接收到数据：" + item);
			
			//过滤掉小于200的数据， 
            if(item > 200) {
            	//将消息转换String
                this.submit("String MSG-" + item);
            }

            this.subscription.request(1);
        }

        @Override
        public void onError(Throwable throwable) {
            //出现异常
            throwable.printStackTrace();
            this.subscription.cancel();
        }

        @Override
        public void onComplete() {
            System.out.println("Processor:数据处理完了");
        }
    }

test-case

    private static void testProcessor() throws InterruptedException {
        Random random = new Random();
        //1.自定义发布者， 发布数据类型为Integer
        SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>();

        // 2.定义处理器Processor
        MyProcessor processor = new MyProcessor();

        // 3.发布者和Processor建立关系
        publisher.subscribe(processor);

        //4.定义订阅者
        Flow.Subscriber<String> subscriber = new Flow.Subscriber<String>() {
            private Flow.Subscription subscription;

            @Override
            public void onSubscribe(Flow.Subscription sb) {
                //建立订阅关系
                this.subscription = sb;

                //2. 请求数据 ----
                this.subscription.request(1);
            }

            @Override
            public void onNext(String item) {
                System.out.println("=============subscriber接收到数据：" + item);

                this.subscription.request(2);
                //已经达到了目标，调用cancel告诉发布者，不在接收数据
//                this.subscription.cancel();
            }

            @Override
            public void onError(Throwable throwable) {
                //出现异常
                throwable.printStackTrace();

                this.subscription.cancel();
            }

            @Override
            public void onComplete() {
                //在publisher.close();时触发..
                System.out.println("数据处理完了");
            }
        };

        //5. Processor同订阅者建立关系
        processor.subscribe(subscriber);

        //4.生产数据，并发布
        publisher.submit(100);
        publisher.submit(200);
        publisher.submit(300);
        publisher.submit(400);

        //5.结束后，关闭发布者
        publisher.close();

        Thread.currentThread().join(1000);
    }

执行结果：

processor接收到数据：100
processor接收到数据：200
processor接收到数据：300
processor接收到数据：400
Processor数据处理完了
=============subscriber接收到数据：String MSG-300
=============subscriber接收到数据：String MSG-400

demo3–背压测试
实现一个场景发布者产生消息的速率 > 订阅者消费消息的速率 && 设置缓冲池大小为2，

private static void testBackup() throws InterruptedException {
        //覆盖默认参数，修改缓冲池最大大小为2
        SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>(ForkJoinPool.commonPool(),2){
            @Override
            public int submit(Integer item) {
                System.out.println("生产数据："+item);
               return  super.submit(item);
            }
        };
        Flow.Subscriber<Integer> subscriber = new Flow.Subscriber<Integer>() {
            private Flow.Subscription subscription;
            @Override
            public void onSubscribe(Flow.Subscription sb) {
                this.subscription = sb;
                this.subscription.request(1);
            }

            @Override
            public void onNext(Integer item) {
                System.out.println("----------------接收到数据：" + item);
                
                //为了模拟耗时操作： 这里sleep..
                try {
                    TimeUnit.MILLISECONDS.sleep(50L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                this.subscription.request(1);
            }

            @Override
            public void onError(Throwable throwable) {
                throwable.printStackTrace();
                this.subscription.cancel();
            }

            @Override
            public void onComplete() {
                System.out.println("数据处理完了");
            }
        };

        // 3.发布者和订阅者 建立订阅关系
        publisher.subscribe(subscriber);

        //4.生产数据，并发布
        Random random = new Random();
        IntStream.rangeClosed(1,1000).forEach(data -> {
            publisher.submit(data);
        });

        //5.结束后，关闭发布者
        publisher.close();

        Thread.sleep(100000L);
    }

执行结果

生产数据：1
生产数据：2
----------------接收到数据：1
生产数据：3
生产数据：4
----------------接收到数据：2
生产数据：5
----------------接收到数据：3
生产数据：6
生产数据：7
----------------接收到数据：4
----------------接收到数据：5

可见，只要缓冲池中有超过2个未处理的数据，消息发布者就会感受到订阅方的压力，而减缓产生数据的速率。

伊布拉西莫
关注
专栏目录
【微服务】spring webflux响应式编程使用详解
congge
10-18 5978
webflux使用详解
java响应式编程_[译]使用JDK 9 Flow API进行响应式编程
weixin_29428137的博客
02-19 492
什么是响应式编程？响应式编程是关于处理数据项的异步流，也就是应用程序在数据项发生时对其进行响应。数据流实质上是指随时间发生的数据项序列。与迭代内存数据相比，这个模型的内存效率更高，因为数据是以流的形式处理的。在响应式编程模型中，有一个Publisher和一个Subscriber。Publisher发布一个数据流，Subscriber异步订阅。该模型还提供了一种机制来引入更高阶的函数，这样就可...
jdk9响应式流
weixin_38400347的博客
03-03 322
简单实现 构建发布者 构建消费者 关联发布者与消费者 发布者发布消息 public static void main(String[] args) throws InterruptedException { //构建发布者 SubmissionPublisher<Integer> publisher = new SubmissionPublisher<>(); //构建消费者 Flow.Subscriber<I
JDK9新特性 Reactive Stream 响应式流
qq_34285557的博客
02-29 2932
JDK9新特性 Reactive Stream 响应式流  本篇主要讲解 JDK9特性 Reactive Stream 响应式流，介绍 Reactive Stream是什么 背压是什么，以及JDK9中提供的关于Reactive Stream的接口和 2个使用案例包括如何使用Processor。  1.Reactive Stream 概念  Reactive Stre...
JDK9特性-Reactive Stream 响应式流
weixin_34037515的博客
10-04 256
初识Reactive Stream Reactive Stream (响应式流/反应流) 是JDK9引入的一套标准，是一套基于发布/订阅模式的数据处理规范。响应式流从2013年开始，作为提供非阻塞背压的异步流处理标准的倡议。 它旨在解决处理元素流的问题——如何将元素流从发布者传递到订阅者，而不需要发布者阻塞，或订阅者有无限制的缓冲区或丢弃。更确切地说，Reactive流目的是“找到最小的一组接口，...
Java 9 - 说说响应式流
一叶不知秋
07-23 2539
最初看到 Java 9 的这个新特性没太在意，及至重新关注到 Spring 5/Springboot 2 的响应式编程的时候才真正重视起 Reactive Streams(响应式流或反应式流)。应用响应式流的编程也就叫做响应式编程(Reactive Programming)，无论是翻译成反应式编程都有些令人摸不准头脑。与此对应的在 Web 设计方面有一个叫做响应式 Web 设计(Responsiv...
响应式编程基础 --- 发布订阅模式、JDK9: Flow
化身强盗的博客
04-27 1049
一、发布订阅模式 1.1 基本概念 反应式编程离不开发布-订阅模式 发布订阅模式有基本的三个概念： 订阅者可以订阅发布者 名为订阅的连接 消息(也叫事件)，它们通过连接传输 1.2 示例：对两个流求和 发布订阅 的一个简单例子就是整合两个信息源的事件并发布给其他用户使用 例如想象成电子表格：C3 = C1+C2这样一个公式，只要C1或者C2更新，C3也会更新这些变化 1、先对保存值的单元格进行建模： private static class SimpleCell { private int v
java-jdk9-jdk-9.0.1-windows-x64-bin.zip
11-15
2. 响应式流（Project Reactor）：通过Stream API提供了反应式编程的支持，用于处理大量数据流。 3. JShell（REPL，Read-Eval-Print Loop）：一个新的命令行工具，允许开发者即时测试和运行Java代码片段，提高了开发...
JDK9官方API文档
02-14
- JDK9引入了G1垃圾收集器作为默认的垃圾收集器，它具有良好的响应时间和总体吞吐量，适用于各种应用环境。 以上只是JDK9部分重要更新的概述，实际的官方API文档会涵盖更多细节，包括每个类、接口和方法的完整描述...
JDK9响应式流使用详解
蜜糖的代码注释
02-03 496
上文中咱们简单提到了JDK9中Flow接口中的静态内部类实现了响应式流的JAVA API，并且提供了一个一个Publisher的实现类SubmissionPublisher。本文将先梳理一下接口中具体的处理流程，然后再以几个调用者的例子来帮助大家理解。 JDK9中的实现 再放上一下上文中的响应式流的交互流程： 订阅者向发布者发送订阅请求。 发布者根据订阅请求生成令牌发送给订阅者。 订阅者根据令牌向发布者发送请求N个数据。 发送者根据订阅者的请求数量返回M(M<=N)个数据 重复3，4 数据发送完毕后
JDK-反应流（响应式流）
最新发布
fl_zxf的专栏
07-05 177
JDK-反应流（响应式流）
Java 9 - 响应式流 ( Reactive Streams ) API 支持
学无止境
07-19 297
【代码】Java - 响应式流 ( Reactive Streams ) API 支持。
浅谈JDK 9—Flow
Java部落格
02-18 1459
一、响应式编程 JDK 9 Flow 是JDK对Reactive Stream (响应式流/反应流) 的实现，Reactive Stream是一套基于发布/订阅模式的数据处理规范。响应式流从2013年开始，作为提供非阻塞背压的异步流处理标准的倡议。 它旨在解决处理元素流的问题——如何将元素流从发布者传递到订阅者，而不需要发布者阻塞，或订阅者需要有无限制的缓冲区或丢弃。更确切地说，Reactive流目的是“找到最小的一组接口，方法和协议，用来描述必要的操作和实体以实现这样的目标：以非阻塞背压方式实现数据的异步
从JDK9的Flow接口说起
cristianoxm的博客
11-10 2553
一、JDK9响应式编程 Java是一个“古老”并且广泛应用的编程语言，但Java9中引入了一些新鲜有趣的特性。这篇文章主要介绍FlowAPI这个新特性，通过FlowAPI我们仅仅使用JDK就能够搭建响应式应用程序，而不需要其他额外的类库，如RxJava或Project Reactor。 尽管如此，当你看到过接口文档后你就会明白到正如字面所说，这只是一个API而已。她仅仅包含了一些Interface和一个实现类： 1.Interface Flow.Publisher<T>定义了生产数据和控制事件的
Java Reactor Stream
程序猿进阶
04-17 2067
一、Reactor 概念 “具有非阻塞负压功能的异步流处理系统” 的标准以及API。 1、Reactive Streams 核心接口 2、Flux 与 Mono 【1】Flux 对象代表一个包含0-N个元素的响应式序列； 【2】Mono 对象代表一个包含0-1个元素的响应式序列； 3、Reactor 操作符 二、Reacotr 基本原理 ......
基于JDK9的SubmissionPublisher设计实践及源码剖析
m0_37288350的博客
08-08 1194
什么是响应式编程 总的来说，Reactive Programming 就是编写关于如何响应事件的编程模式，这些事件包括：用户输入，数据流，系统状态，变量的变化等等。 总结一下，响应式编程通常会用在一个事件流相关的场景中，在一个事件流中，一旦触发第一个事件，后续的事件会被依次触发，就像一个Pipeline 系统，不断有输入和输出。 如何使用java进行响应式编程 SubmissionPublishe...
WebFlux响应式编程基础之 4 reactive stream 响应式流
炫的博客
08-03 1855
第4章 reactive stream 响应式流
java publisher_我们如何在Java 9中实现SubmissionPublisher类？
weixin_28727321的博客
02-16 449
从Java 9开始，我们可以通过引入四个核心接口(Publisher，Subscriber，Subscription，Processor和一个具体的类)来创建Reactive Streams：实现Publisher接口的SubmissionPublisher。每个接口都扮演着不同的角色，这与响应流的原理相对应。我们可以使用SubmissionPublisher类的Submit()方法将提供的项目发...
JDK9 Reactive Stream
hxt的博客
04-18 501
1、概念 基于发布订阅者模式处理规范（机制），在JDK中真正叫法是FlowAPI 2、背压（backpress） 背压指的发布者和订阅者之间的互动 订阅者可以告诉发布者自己需要多少数据，可以调节数据流量，不会导致发布者发布数据过多导致数据浪费或压垮订阅者 3、Reactive Stream主要接口 java.util.concurrent.Flow类中定义的接口： 1）、Publisher&l...
jdk9 代替observable
05-13
在 JDK 9 中，引入了一种新的响应式流 API，称为 Flow API，它提供了一种更加现代和灵活的方式来实现响应式编程。在 Flow API 中，Observable 被替换为 Publisher，而 Observer 被替换为 Subscriber。Publisher 接口...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值