RxJava之三—— observeOn()与subscribeOn()的详解
来源:互联网 发布:管家的面 淘宝 编辑:程序博客网 时间:2024/05/17 01:08
转载请标明出处:http://blog.csdn.net/xx326664162/article/details/51967967 文章出自:薛瑄的博客
你也可以查看我的其他同类文章,也会让你有一定的收货!
为什么多次调用subscribeOn()却只有第一个起作用?
为什么多次调用observeOn()却可以切换到不同线程
observeOn()后能不能再次调用subscribeOn()?
如果你有这些疑问,那接下来的内容必定能解决你心头的疑惑
subscribeOn()和observeOn()的区别
subscribeOn()和observeOn()都是用来切换线程用的
- subscribeOn()改变调用它之前代码的线程
- observeOn()改变调用它之后代码的线程
一、subscribeOn()
在讲解他的原理之前,先来一个简单的例子,有个感性认识,学起来更轻松
先说结论:subscribeOn 作用于该操作符之前的 Observable 的创建操符作以及 doOnSubscribe 操作符 ,换句话说就是 doOnSubscribe 以及 Observable 的创建操作符总是被其之后最近的 subscribeOn 控制 。没看懂不要紧,看下面代码和图你就懂了。
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
结果如下:
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
3号框中的.doOnSubscribe(() -> threadInfo(“.doOnSubscribe()-2”)) 的之后由于没有subscribeOn操作符所以回调到该段代码被调用的线程(即主线程)
由于 subscribe 之前 没有 使用observeOn 指定Scheduler,所以.onNext()的线程是和OnSubscribe.call()使用相同的Scheduler 。
下面通过源码来分析一下:
1、示例代码:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
运行如下:
- 1
- 2
- 1
- 2
2、subscribeOn()源代码
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
很明显,会走if之外的方法。
在这里我们可以看到,又创建了一个OperatorSubscribeOn对象,但创建时传入的参数为OperatorSubscribeOn(this,scheduler),我们看一下此对象以及其对应的构造方法
3、create()的源代码:
- 1
- 2
- 3
- 1
- 2
- 3
我们看到这个方法,使用OperatorSubscribeOn这个类,来创建一个新的Observable,那就把它叫做Observable_2,把原来的Observable叫做Observable_1
4、OperatorSubscribeOn类的源代码:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- OperatorSubscribeOn类implements 了Onsubscribe接口,并实现call()方法
- OperatorSubscribeOn的构造方法,
- 保存了Observable对象,就是调用了subscribeOn()方法的Observable对象
- 并保存了Scheduler对象。
这里做个总结。
把Observable.create()创建的称之为Observable_1,OnSubscribe_1。
把subscribeOn()创建的称之为Observable_2,OnSubscribe_2
Observable_1, OnSubscribe_1是由示例代码的第1、2行创建的
OperatorSubscribeOn类implements Onsubscribe类,所以可以当做Onsubscribe类使用。(OnSubscribe_2)
并且OnSubscribe_2中保存了Observable_1的应用,即source。(在OperatorSubscribeOn源代码的第8行)
在subscribeOn()源代码的倒数第二行,
create(new OperatorSubscribeOn<T>(this, scheduler))
返回新创建的Observable_2对象。
4.1、分析call()方法。
- inner.schedule()改变了线程,此时Action的call()在我们指定的线程中运行。
- 示例代码的Subscriber被包装了一层,赋给对象S(Subscriber_2)。见上面代码21行。
- source.unsafeSubscribe(s);,
- 注意:source是Observable_1对象,这里的s就是Subscriber_2
- 因为调用过subscribeOn(Schedulers.io())后,返回Observable_2对象,所以示例代码第13行代码的subscribe()就是Observable_2.subscribe(),也就是执行OnSubscribe_2的call()方法(即OperatorSubscribeOn类的源代码的第12行)。
4.2 看一下source.unsafeSubscribe(s);(第65行)代码都做了什么
这里的source就是Observable_1,s是Subscriber_2
unsafeSubscribe()源代码:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
关键代码:
- 1
- 1
该方法即调用了OnSubscribe_1.call()方法。注意,此时的call()方法在我们指定的线程中运行。那么就起到了改变线程的作用。
对于以上线程,我们可以总结,其有如下流程:
Observable.create() : 创建了Observable_1和OnSubscribe_1;
subscribeOn(): 创建Observable_2和OperatorSubscribeOn(OnSubscribe_2),同时OperatorSubscribeOn保存了Observable_1的引用。
示例代码中的subscribe(Observer) 实际上就是调用Observable_2.subscribe(Observer):
- 调用OperatorSubscribeOn的call()。call()改变了线程的运行,并且调用了Observable_1.unsafeSubscribe(s);
- Observable_1.unsafeSubscribe(s);,该方法的实现中调用了OnSubscribe_1的call()。
这样就实现了在指定线程运行OnSubscribe的call()函数,无论我们的subscribeOn()放在哪里,他改变的是subscribe()的过程,而不是onNext()的过程。
那么如果有多个subscribeOn(),那么线程会怎样执行呢。如果按照我们的逻辑,有以下程序
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
那么,我们根据之前的源码分析其执行逻辑。
Observable.just(“ss”),创建Observable,OnSubscribe
Observable_1.subscribeOn(Schedulers.io()):创建Observable_1,OperatorSubscribeOn_1并保存Observable的引用。
Observable_2.subscribeOn(Schedulers.newThread()):创建Observable_2,OperatorSubscribeOn_2并保存Observable_1的引用。
Observable_3.subscribe():
- 调用OperatorSubscribeOn_2.call(),改变线程为Schedulers.newThread()。
- 调用OperatorSubscribeOn_1.call(),改变线程为Schedulers.io()。
- 调用OnSubscribe.call(),此时call()运行在Schedulers.io()。
根据以上逻辑分析,会按照1的线程进行执行。
二、observeOn()
先说结论:observeOn作用于该操作符之后操作符直到出现新的observeOn操作符
举个例子:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
结果如下:
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
下面通过源码来进行分析:
1、observeOn()源码
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
这里引出了lift()函数
- 1
- 2
- 3
- 1
- 2
- 3
关于lift的详细介绍,如果不明白lift的原理,参考这里:RxJava 之二—— Lift()详解
用OperatorObserveOn对象,创建OnSubscribeLift对象(实现了OnSubscribe接口),接着创建Observable对象。为了加以区分,这里我们把OnSubscribeLift叫做OnSubscribe_2,Observable叫做Observable_2。
2、OperatorObserveOn代码:
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193
- 194
- 195
- 196
- 197
- 198
- 199
- 200
- 201
- 202
- 203
- 204
- 205
- 206
- 207
- 208
- 209
- 210
- 211
- 212
- 213
- 214
- 215
- 216
- 217
- 218
- 219
- 220
- 221
- 222
- 223
- 224
- 225
- 226
- 227
- 228
- 229
- 230
- 231
- 232
- 233
- 234
- 235
- 236
- 237
- 238
- 239
- 240
- 241
- 242
- 243
- 244
- 245
- 246
- 247
- 248
- 249
- 250
- 251
- 252
- 253
- 254
- 255
- 256
- 257
- 258
虽然代码很长,但是也就是三部分
- 构造函数,
- 实现Operator所继承的Func1中的call()函数
- 静态内部类ObserveOnSubscriber< T>
下面来逐一分析:
因为调用Observable.等函数而需要创建的称之为Observable_1,Subscriber_1。
因为调用observeOn()而创建的称之为Observable_2,Subscriber_2
2.1、创建OperatorObserveOn对象
这段代码,主要功能就是创建OperatorObserveOn对象
既然是Operator,那么它的职责就是把一个Subscriber转换成另外一个Subscriber,
2.2、OperatorObserveOn对象中的call()函数返回ObserveOnSubscriber对象(Subscriber_2)
我们来看下call函数都做了什么:
创建一个ObserveOnSubscriber类(继承Subscriber< T>(Subscriber_2))(OperatorObserveOn代码第35行),在参数中传入Subscriber_1(即局部变量child)和scheduler(指定线程)等参数。
ObserveOnSubscriber是一个静态类也是在OperatorObserveOn类中实现的(OperatorObserveOn代码第53行)
既然是Subscriber那么肯定有onNext(), onComplete() 和onError() 看最主要的onNext(),第118行
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
这里做了两件事,
- 把执行的结果缓存到一个队列里,这里的on对象,不是Subscriber_1。
- 调用schedule()启动传入的线程所创建的worker
2.3、schedule()代码:
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
我们这里需要注意下:
在调用observeOn()前的代码,把结果传入到onNext()就是它们最终的目标,它们并不关心后续的流程,调用了observeOn(),结果被传入到ObserveOnSubscriber的onNext()中。
recursiveScheduler 就是之前我们传入的Scheduler,就是在observeOn()传入的指定线程,例如:AndroidScheluders.mainThread()
2.4、我们看下在scheduler()中调用的call()方法代码,call()方法只能由scheduler()去调用执行
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
OK,在Scheduler启动后, 我们在Observable.subscribe(a)传入的a就是这里的localChild(即Subscriber_1,是在第35行代码传递进来的) , 我们看到,在call中终于调用了它的onNext方法,把真正的结果传了出去,此时是工作在observeOn()指定的线程。
那么总结起来的结论就是:
- observeOn 对调用之前的序列默不关心,也不会要求之前的序列运行在指定的线程上
- observeOn 对之前的序列产生的结果先缓存起来,然后再在指定的线程上,推送给最终的subscriber
下面给出两次调用observeOn()的示意图
复杂情况
我们经常多次使用subscribeOn()切换线程,那么以后是否可以组合observeOn()和subscribeOn()达到自由切换的目的呢?
组合是可以的,但是他们的执行顺序是有条件的,如果仔细分析的话,可以知道observeOn()调用之后,再调用subscribeOn()是无效的,原因是什么?
因为subscribeOn()改变的是subscribe()这句调用所在的线程,大多数情况,产生内容和消费内容是在同一线程的,所以改变了产生内容所在的线程,就改变了消费内容所在的线程。
对subscribeOn()的调用是自下向上,所以多次调用subscribeOn(),结果会被最上面的subscribeOn()覆盖。(生成和消费都会被覆盖)
observeOn()之上有subscribeOn()调用
observeOn()的工作原理是把消费结果先缓存,再切换到新线程上让原始消费者消费,它和生产者是没有一点关系的,就算subscribeOn()调用了,也只是改变observeOn()这个消费者所在的线程,和OperatorObserveOn中存储的原始消费者一点关系都没有,它还是由observeOn()控制。observeOn()之下有subscribeOn()调用
这也不会改变observeOn()所指定的消费线程,因为observeOn()是自上而下调用,对subscribeOn()的调用是自下向上,在observeOn()指定的线程会覆盖下面subscribeOn()指定线程来去消费
用一张图来解释当多个 subscribeOn() 和 observeOn() 混合使用时,线程调度是怎么发生的(由于图中对象较多,相对于上面的图对结构做了一些简化调整):
参考:http://blog.csdn.net/jdsjlzx/article/details/51685769
http://blog.csdn.net/jdsjlzx/article/details/51686152
https://segmentfault.com/a/1190000004856071
https://gank.io/post/560e15be2dca930e00da1083
你真的会用RxJava么?RxJava线程变换之observeOn与subscribeOn
- RxJava之三—— observeOn()与subscribeOn()的详解
- RxJava之四—— observeOn()与subscribeOn()的详解
- observeOn()与subscribeOn()的详解
- RxJava observeOn()与subscribeOn()的关系
- RxJava observeOn()与subscribeOn()的关系
- rxjava的observeOn和subscribeOn
- RxJava线程切换之subscribeOn()和observeOn()的总结
- RxJava源码分析之subscribeOn和observeOn
- RxJava源码分析之subscribeOn和observeOn
- subscribeOn与observeOn的是是非非
- observeOn()与subscribeOn()的区别
- RXJava observeOn和subscribeOn的区别
- RXjava observeOn subscribeOn 解析
- Android函数响应式编程——必学的RxJava辅助操作符delay、Do、subscribeOn、observeOn、timeout
- Android RxJava 将subscribeOn与observeOn简化合并
- rxjava的ObserveOn和SubscribeOn的一些结论
- Rxjava(线程类)--observeOn和subscribeOn实例
- subscribeOn和observeOn的关系,使用注意事项
- 串行线程封闭(Serial Thread Confinement)
- SOUI假窗口释放资源后操作界面控件崩溃
- 线程间同步与互斥
- 批处理命令 从SVN检出代码 并使用MSBulid命令发布打包网站程序
- (转) 基于STM32F103ZET6的UART通讯实现
- RxJava之三—— observeOn()与subscribeOn()的详解
- Python中双精度浮点数操作并分行显示操作实例
- 绪论
- HTML5中新增的input类型及其属性
- 虚拟局域网和局域网
- Python中的random模块
- 历史百科-每天读点历史
- 刷新iframe,父页面连带刷新
- java.lang.IllegalArgumentException: Invalid 'log4jConfigLocation' parameter: