RxJava 驯服数据流之 hot & cold Observable

最新推荐文章于 2023-02-28 22:18:08 发布
最新推荐文章于 2023-02-28 22:18:08 发布
阅读量6.8k 收藏 5
点赞数 2
分类专栏： Android开发 RxJava入门 文章标签： RxJava 热启动 冷启动

Observable 数据流有两种类型：hot 和 cold。这两种类型有很大的不同。本节介绍他们的区别，以及作为 Rx 开发者应该如何正确的使用他们。

Cold observables

只有当有订阅者订阅的时候， Cold Observable 才开始执行发射数据流的代码。并且每个订阅者订阅的时候都独立的执行一遍数据流代码。 Observable.interval 就是一个 Cold Observable。每一个订阅者都会独立的收到他们的数据流。

Observable<Long> cold = Observable.interval(200, TimeUnit.MILLISECONDS);

cold.subscribe(i -> System.out.println("First: " + i));
Thread.sleep(500);
cold.subscribe(i -> System.out.println("Second: " + i));

结果：

First: 0
First: 1
First: 2
Second: 0
First: 3
Second: 1
First: 4
Second: 2
...

虽然这两个 Subscriber 订阅到同一个Observable 上，只是订阅的时间不同，他们都收到同样的数据流，但是同一时刻收到的数据是不同的。

在本教程中之前所见到的 Observable 都是 Cold Observable。 Observable.create 创建的也是 Cold Observable，而 just, range, timer 和 from 这些创建的同样是 Cold Observable。

Hot observables

Hot observable 不管有没有订阅者订阅，他们创建后就开发发射数据流。 一个比较好的示例就是 鼠标事件。 不管系统有没有订阅者监听鼠标事件，鼠标事件一直在发生，当有订阅者订阅后，从订阅后的事件开始发送给这个订阅者，之前的事件这个订阅者是接受不到的；如果订阅者取消订阅了，鼠标事件依然继续发射。

Publish

Cold Observable 和 Hot Observable 之间可以相互转化。使用 publish 操作函数可以把 Cold Observable 转化为 Hot Observable。

public final ConnectableObservable<T> publish()

这里写图片描述

publish 返回一个 ConnectableObservable 对象，这个对象是 Observable 的之类，多了三个函数：

public final Subscription connect()
public abstract void connect(Action1<? super Subscription> connection)
public Observable<T> refCount()

另外还有一个重载函数，可以在发射数据之前对数据做些处理：

public final <R> Observable<R> publish(Func1<? super Observable<T>,? extends Observable<R>> selector)

之前介绍的所有对 Observable 的操作都可以在 selector 中使用。你可以通过 selector 参数创建一个 Subscription ，后来的订阅者都订阅到这一个 Subscription 上，这样可以确保所有的订阅者都在同一时刻收到同样的数据。

这个重载函数返回的是 Observable 而不是 ConnectableObservable， 所以下面讨论的操作函数无法在这个重载函数返回值上使用。

connect

ConnectableObservable 如果不调用 connect 函数则不会触发数据流的执行。当调用 connect 函数以后，会创建一个新的 subscription 并订阅到源 Observable （调用 publish 的那个 Observable）。这个 subscription 开始接收数据并把它接收到的数据转发给所有的订阅者。这样，所有的订阅者在同一时刻都可以收到同样的数据。

ConnectableObservable<Long> cold = Observable.interval(200, TimeUnit.MILLISECONDS).publish();
cold.connect();

cold.subscribe(i -> System.out.println("First: " + i));
Thread.sleep(500);
cold.subscribe(i -> System.out.println("Second: " + i));

结果：

First: 0
First: 1
First: 2
Second: 2
First: 3
Second: 3
First: 4
Second: 4
First: 5
Second: 5

Disconnecting

connect 函数返回的是一个 Subscription，和 Observable.subscribe返回的结果一样。 可以使用这个 Subscription 来取消订阅到 ConnectableObservable。 如果调用 这个 Subscription 的 unsubscribe 函数，可以停止把数据转发给 Observer，但是这些 Observer 并没有从 ConnectableObservable 上取消注册，只是停止接收数据了。如果再次调用 connect ， 则 ConnectableObservable 开始一个新的订阅，在 ConnectableObservable 上订阅的 Observer 会再次开始接收数据。

ConnectableObservable<Long> connectable = Observable.interval(200, TimeUnit.MILLISECONDS).publish();
Subscription s = connectable.connect();

connectable.subscribe(i -> System.out.println(i));

Thread.sleep(1000);
System.out.println("Closing connection");
s.unsubscribe();

Thread.sleep(1000);
System.out.println("Reconnecting");
s = connectable.connect();

结果：

0
1
2
3
4
Closing connection
Reconnecting
0
1
2
...

通过调用 connect 来重新开始订阅，会创建一个新的订阅。如果源 Observable 为 Cold Observable 则数据流会重新执行一遍。

如果你不想结束数据流，只想从 publish 返回的 Hot Observable 上取消注册，则可以使用 subscribe 函数返回的 Subscription 对象。

ConnectableObservable<Long> connectable = Observable.interval(200, TimeUnit.MILLISECONDS).publish();
Subscription s = connectable.connect();

Subscription s1 = connectable.subscribe(i -> System.out.println("First: " + i));
Thread.sleep(500);
Subscription s2 = connectable.subscribe(i -> System.out.println("Second: " + i));

Thread.sleep(500);
System.out.println("Unsubscribing second");
s2.unsubscribe();

结果：

First: 0
First: 1
First: 2
Second: 2
First: 3
Second: 3
First: 4
Second: 4
Unsubscribing second
First: 5
First: 6

refCount

ConnectableObservable.refCount 返回一个特殊的 Observable， 这个 Observable 只要有订阅者就会继续发射数据。

Observable<Long> cold = Observable.interval(200, TimeUnit.MILLISECONDS).publish().refCount();

Subscription s1 = cold.subscribe(i -> System.out.println("First: " + i));
Thread.sleep(500);
Subscription s2 = cold.subscribe(i -> System.out.println("Second: " + i));
Thread.sleep(500);
System.out.println("Unsubscribe second");
s2.unsubscribe();
Thread.sleep(500);
System.out.println("Unsubscribe first");
s1.unsubscribe();

System.out.println("First connection again");
Thread.sleep(500);
s1 = cold.subscribe(i -> System.out.println("First: " + i));

结果：

First: 0
First: 1
First: 2
Second: 2
First: 3
Second: 3
Unsubscribe second
First: 4
First: 5
First: 6
Unsubscribe first
First connection again
First: 0
First: 1
First: 2
First: 3
First: 4

如果没有订阅者订阅到 refCount 返回的 Observable，则不会执行数据流的代码。如果所有的订阅者都取消订阅了，则数据流停止。重新订阅再回重新开始数据流。

replay

public final ConnectableObservable<T> replay()

这里写图片描述

replay 和 ReplaySubject 类似。当和源 Observable 链接后，开始收集数据。当有 Observer 订阅的时候，就把收集到的数据线发给 Observer。然后和其他 Observer 同时接受数据。

ConnectableObservable<Long> cold = Observable.interval(200, TimeUnit.MILLISECONDS).replay();
Subscription s = cold.connect();

System.out.println("Subscribe first");
Subscription s1 = cold.subscribe(i -> System.out.println("First: " + i));
Thread.sleep(700);
System.out.println("Subscribe second");
Subscription s2 = cold.subscribe(i -> System.out.println("Second: " + i));
Thread.sleep(500);

结果：

Subscribe first
First: 0
First: 1
First: 2
Subscribe second
Second: 0
Second: 1
Second: 2
First: 3
Second: 3

replay 和 publish 一样也返回一个 ConnectableObservable 。所以我们可以在上面使用 refCount 来创建新的 Observable 也可以取消注册。

replay 有 8个重载函数：

ConnectableObservable<T> replay()
<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector)
<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector, int bufferSize)
<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector, int bufferSize, long time, java.util.concurrent.TimeUnit unit)
<R> Observable<R> replay(Func1<? super Observable<T>,? extends Observable<R>> selector, long time, java.util.concurrent.TimeUnit unit)
ConnectableObservable<T> replay(int bufferSize)
ConnectableObservable<T> replay(int bufferSize, long time, java.util.concurrent.TimeUnit unit)
ConnectableObservable<T> replay(long time, java.util.concurrent.TimeUnit unit)

有三个参数 bufferSize、 selector 和 time （以及指定时间单位的 unit）

  • bufferSize 用来指定缓存的最大数量。当新的 Observer 订阅的时候，最多只能收到 bufferSize 个之前缓存的数据。
  • time, unit 用来指定一个数据存货的时间，新订阅的 Observer 只能收到时间不超过这个参数的数据。
  • selector 和 publish(selector) 用来转换重复的 Observable。

下面是一个 bufferSize 的示例：

ConnectableObservable<Long> source = Observable.interval(1000, TimeUnit.MILLISECONDS)
    .take(5)
    .replay(2);

source.connect();
Thread.sleep(4500);
source.subscribe(System.out::println);

结果：

2
3
4

cache

cache 操作函数和 replay 类似，但是隐藏了 ConnectableObservable ，并且不用管理 subscription 了。当第一个 Observer 订阅的时候，内部的 ConnectableObservable 订阅到源 Observable。后来的订阅者会收到之前缓存的数据，但是并不会重新订阅到源 Observable 上。

public final Observable<T> cache()
public final Observable<T> cache(int capacity)

这里写图片描述

Observable<Long> obs = Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(5)
    .cache();

Thread.sleep(500);
obs.subscribe(i -> System.out.println("First: " + i));
Thread.sleep(300);
obs.subscribe(i -> System.out.println("Second: " + i));

结果：

First: 0
First: 1
First: 2
Second: 0
Second: 1
Second: 2
First: 3
Second: 3
First: 4
Second: 4

从上面示例中可以看到，只有当有订阅者订阅的时候，源 Observable 才开始执行。当第二个订阅者订阅的时候，会收到之前缓存的数据。

需要注意的是，如果所有的订阅者都取消订阅了 内部的 ConnectableObservable 不会取消订阅，这点和 refCount 不一样。只要第一个订阅者订阅了，内部的 ConnectableObservable 就链接到源 Observable上了并且不会取消订阅了。 这点非常重要，因为当我们一单订阅了，就没法取消源 Observable了， 直到源 Observable 结束或者程序内存溢出。 可以指定缓存个数的重载函数也没法解决这个问题，缓存限制只是作为一个优化的提示，并不会限制内部的缓存大小。

Observable<Long> obs = Observable.interval(100, TimeUnit.MILLISECONDS)
    .take(5)
    .doOnNext(System.out::println)
    .cache()
    .doOnSubscribe(() -> System.out.println("Subscribed"))
    .doOnUnsubscribe(() -> System.out.println("Unsubscribed"));

Subscription subscription = obs.subscribe();
Thread.sleep(150);
subscription.unsubscribe();

结果：

Subscribed
0
Unsubscribed
1
2
3
4

上面的示例中，doOnNext 打印源 Observable 发射的每个数据。而 doOnSubscribe 和doOnUnsubscribe 打印缓存后的 Observable 的订阅和取消订阅事件。可以看到当订阅者订阅的时候，数据流开始发射，取消订阅数据流并不会停止。

Multicast

share 函数是 Observable.publish().refCount() 的别名。可以让你的订阅者分享一个 subscription，只要还有订阅者在，这个 subscription 就继续工作。

本文出自 云在千峰 http://blog.chengyunfeng.com/?p=975

一叶飘舟
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RXjava网络获取图片数据的方法
01-21
本文实例为大家分享了RXjava网络获取图片数据的具体代码，供大家参考，具体内容如下 RXjava // An highlighted block image = findViewById(R.id.tu); Observable.create(new ObservableOnSubscribe() { @...
大揭秘，Android Flow面试官最爱问的7个问题
Android23333的博客
02-04 1014
而Flow的冷流特性使其更加灵活，可以根据需要按需产生数据，避免了不必要的计算和资源浪费。在订阅者加入后才开始产生事件，因此可能存在热启动问题，即在订阅前产生的事件会被忽略。这样，在数据生产速度大于消费速度时，可以保证消费者只处理最新的数据，避免队列无限增长导致的内存问题。允许有多个订阅者，并能缓存一定数量的最新元素，适用于多个订阅者需要获取历史元素的场景。本身并没有对线程的调度进行限制，因此在多线程环境中，需要在合适的协程上下文中使用。会丢弃掉生产者产生的新数据，只保留最新的数据，从而避免背压。
Rxjava中的Hot Observable 和 Cold Observable
qq_15327675的博客
11-10 1110
在Rxjava中Observable 有 Hot 和 Cold之分.     Hot Observable:         Hot Observable无论有没有观察者进行订阅事件始终都会发生. 当Hot Observable 有多个订阅者时(即多个订阅者进行订阅时), Hot Observable与订阅者们的关系是一对多的关系,可以与多个订阅者共享信息.   Cold Observa...
Kotlin学习：5.2、异步数据流 Flow
嗯...
02-28 2065
sample操作符与debounce操作符有点像，但是却限制了一个周期性时间，sample操作符获取的是一个周期内的最新的数据，可以理解为debounce操作符增加了周期的限制。当文件下载时，对应的后台下载进度，就可以通过Flow里面的emit发送数据，通过collect接收对应的数据。元素会变换完，以流的形式继续下发，并且某个元素需要耗时，它后面的元素不会等待。元素会变换完，以流的形式继续下发，并且某个元素需要耗时，它后面的元素会等待。conflate()，合并发射项，处理最新的值，不对每个值进行处理；
深潜Kotlin协程（十八）：冷热数据流
RikkaTheWorld
06-29 1457
系列电子书：传送门在这里插入图片描述](https://img-blog.csdnimg.cn/d2893ae770c34a7b924a3372997cbafb.png) Kotlin 协程最初只有 Channel，但创造者意识到这个是不够的。 Channel 是一种热数据流，但是我们经常需要冷数据流。了解热数据流和冷数据流之间的区别可以帮助我们更好的学习 Flow 和其他相关的技术，因为你日常使用的大多数数据源都属于这两类之一。集合（List、Set）是热的，而序列和 Java Stream 是冷的。Ch
RxJava2.0使用记录
haizhuo的博客
09-06 297
前言 契机是最近准备上手Flow了，想回顾一下Rxjava。 一图流 补充1：图示单词意思翻译 Observable 可观测量；源 Observer 观察者 Subject 主题 Subscriber 订阅者 对照图，我们知道可以被观察变化的是各种数据源Source和出版者Publisher，而观察变化的是各种Observer 观察者和Subscriber 订阅者 事件订阅我们可以类比成一根水管的上下游，值得关心的地方有很多，比如上游发送到顺序下游接收顺序、水滴在流动中途的变化、水滴的大小等。配合操作
RxJava 两种生产和消费模式，（冷）cold和（热）hot
qq_18478183的博客
09-04 808
RxJava目前有两种发布和订阅模式。
rxjava背压_关于Rx Java：如何在RxJava RabbitMQ Observable中实现背压？
weixin_39524048的博客
12-18 243
我是RxJava的新手，它试图从支持无损背压的RabbitMQ队列中实现消息的Observable。 我设法从Spring AMQP MessageListener创建了一个Observable。 这样可以在同步环境中很好地处理背压(例如，调用堆栈阻塞)，但是一旦引入了多个线程，背压就会如您所愿地消失在窗口之外。 该类如下：import org.springframework.amqp.core....
「正确」的使用Kotlin Flow进行搜索优化，androidsdk开发文档
m0_66264699的博客
01-20 188
错在了哪 ==== 我先把那篇文章中错误的代码贴上来： // 错误代码 binding.etSearch.doOnTextChanged { text, _, _, _ -> searchFilter(text.toString()) } private fun searchFilter(str:String){ flow { emit(str) } .debounce(400) .filter { it.isNotEmpty() } .catch { LogUtils.d(it.message) }
Observable 之冷和热
weixin_33767813的博客
10-17 240
本文讲的是Observable 之冷和热， 简单来说：如果不想重复创建生产者（producer），你需要使用热 Observable 冷：Observable 自行创建生产者 // COLD var cold = new Observable((observer) => { var producer = new Producer(); ...
RxJava响应式编程原理
11-14
RxJava提供了一系列操作符和扩展，使得开发人员可以以声明式方式编写异步代码，并能够轻松地处理异步任务、事件和数据流。 响应式编程是一种编程范式，它强调在数据流系统中，以流式方式处理异步事件。与传统的命令...
RxSwift学习之Observable的新建、订阅及取消订阅
08-29
主要给大家介绍了关于RxSwift学习教程之Observable的相关资料，文中详细的给大家介绍了关于新建Observable、订阅Observable和取消订阅并消除内存泄漏等相关的内容，需要的朋友可以参考借鉴，下面来一起看看吧。
Android代码-轻松将RxJava Observable组合在一起
08-06
RxGroups lets you group RxJava Observables together in groups and tie them to your Android lifecycle. This is especially useful when used with Retrofit. For simple scenarios you can probably just let ...
observable-stream:玩具可观察流
04-11
可观察流玩具可观察到的溪流。 使用@jvanbruegge的帖子一些代码示例构建。
A4打印模板-画图设计设计师产品草稿图纸-网格纸A4打印模板高清待办练字模板PDF下载.pdf
最新发布
04-23
A4打印模板-画图设计设计师产品草稿图纸-网格纸A4打印模板高清待办练字模板PDF下载
ISA-95 流程圣经，描述了PLM企业资源计划、MES制造执行系统、ERP企业资源计划系统、SCM供应链管理系统之间的关系
04-23
ISA-95 流程圣经，描述了PLM企业资源计划、MES制造执行系统、ERP企业资源计划系统、SCM供应链管理系统、客户关系管理CRM之间的关系
年会活动颁奖领奖音乐74首
04-23
颁奖领奖音乐在各种表彰、嘉奖或庆祝场合中扮演着至关重要的角色，其作用主要体现在以下几个方面： 1.营造氛围： 2.情绪引导： 3.节奏控制： 4.品牌塑造： 5.文化表达： 6.致敬与激励： 综上所述，颁奖领奖音乐在颁奖典礼中不仅作为背景音效存在，更是情感传递、氛围营造、流程把控、品牌塑造、文化展现和精神激励的重要载体，对于提升典礼的整体效果和观众体验有着不可忽视的影响。
这个项目是用于个人参加浙江大学移动创新竞赛而使用。.zip
04-23
这个项目是用于个人参加浙江大学移动创新竞赛而使用。
RxJava框架中Observable<T>
06-08
RxJava 框架中的 `Observable<T>` 是一个可观察的数据流对象，用于支持响应式编程。它可以发射一系列的事件，包括数据、错误和完成事件。这些事件可以异步地被观察者（Observer）处理。 `Observable<T>` 可以被订阅，一旦被订阅，它就开始发射事件。当有新的事件发生时，`Observable<T>` 会通知订阅者，订阅者可以对这些事件做出响应。 `Observable<T>` 可以经过一系列的操作符处理后，再将结果发射给订阅者。这些操作符包括 map、filter、flatMap 等等，可以对数据流进行转换和过滤，从而实现更加复杂的业务需求。 总之，`Observable<T>` 是 RxJava 框架中的一个核心类，它提供了一种异步、响应式的编程方式，可以简化代码，提高性能，让开发者更加专注于业务逻辑的实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值