[译] 管中窥豹：RxJava 与 Kotlin 协程的对比

最新推荐文章于 2024-04-20 13:48:27 发布

2401_83621499

最新推荐文章于 2024-04-20 13:48:27 发布

阅读量910

点赞数 24

分类专栏：程序员学习文章标签： rxjava kotlin echarts

本文链接：https://blog.csdn.net/2401_83621499/article/details/136861039

版权

程序员学习专栏收录该内容

8 篇文章 0 订阅

订阅专栏

本文详细介绍了如何在RxJava2中处理阻塞操作，如`suspended`函数的调用，以及如何使用BlockingScheduler实现主线程回调。作者还探讨了如何优化重试和超时机制，以及与协程的比较。

摘要由CSDN通过智能技术生成

接下来我们看看 RxJava 2 是如何实现相同操作的。让人失望的是，如果函数前加了 suspended，就无法通过普通方式调用了，所以我们还得用普通方法重写一下两个函数：

fun f3(i: Int) : Int {
Thread.sleep(if (i != 2) 2000L else 200L)
return 1
}

fun f4(i: Int) : Int {
Thread.sleep(if (i != 2) 2000L else 200L)
return 2
}

为了匹配阻塞外部环境的功能，我们采用 RxJava 2 Extensions 中的 BlockingScheduler 来提供返回到主线程的功能。顾名思义，它阻塞了一开始的调用者/主线程，直到有任务通过调度器来提交并运行。

fun reactiveWay() {
RxJavaPlugins.setErrorHandler({ }) // (1)

val sched = BlockingScheduler() // (2)
sched.execute {
val t0 = System.currentTimeMillis()
val count = Array(1, { 0 }) // (3)

Single.defer({ // (4)
val c = count[0]++;
println(“Attempt " + (c + 1) +
" at T=” + (System.currentTimeMillis() - t0))

Single.zip( // (5)
Single.fromCallable({ f3© })
.subscribeOn(Schedulers.io()),
Single.fromCallable({ f4© })
.subscribeOn(Schedulers.io()),
BiFunction<Int, Int> { a, b -> a + b } // (6)
)
})
.doOnDispose({ // (7)
println(" Cancelling at T=" +
(System.currentTimeMillis() - t0))
})
.timeout(500, TimeUnit.MILLISECONDS) // (8)
.retry({ x, e ->
println(" Crash at " +
(System.currentTimeMillis() - t0))
x < 3 && e is TimeoutException // (9)
})
.doAfterTerminate { sched.shutdown() } // (10)
.subscribe({
println(it)
println(“End at T=” +
(System.currentTimeMillis() - t0)) // (11)
},
{ it.printStackTrace() })
}
}

实现起来有点长，对那些不熟悉 lambda 的人来说看起来可能有点可怕。

众所周知 RxJava 2 无论如何都会传递异常。在 Android 上，无法传递的异常会使应用崩溃，除非使用 RxJavaPlugins.setErrorHandler 来捕获。在此，因为我们知道取消事件会打断 Thread.sleep() ，调用栈打出来的结果只会是一团乱麻，我们也不会去注意这么多的异常。
设置 BlockingScheduler 并分发第一个执行的任务，以及剩下的主线程执行逻辑。这是由于一旦锁住， start() 将会给主线程增加一个活锁状态，直到有任何随后事件打破锁定，主线程才会继续执行。
设置一个堆变量来记录重试次数。
一旦有通过 Single.defer 的订阅，计数器加一并打印 “Attempt” 字符串。该操作符允许保留每个订阅的状态，这正是我们在下游执行的 retry() 操作符所期望的。
使用 zip 操作符来异步执行两个元素的计算，二者都在后台线程执行自己的函数。
当二者都完成时，将结果相加。
为了让超时取消，使用 doOnDispose 操作符来打印当前状态和时间。
使用 timeout 操作符定义求和的超时。如果超时则会发送 TimeoutException（例如该场景下没有反馈时）。
retry 操作符的重载提供了重试时间以及当前错误。打印错误后，应该返回 true ——也就是说必须执行重试——如果重试次数小于三并且当前错误是 TimeoutException 的话。任何其他错误只会终止而不是触发重试。
一旦完成，我们需要关闭调度器，来让释放主线程并退出JVM。
当然，在完成前我们需要打印求和结果以及整个操作的耗时。

可能有人说，这比协程的实现复杂多了。不过……至少跑起来了：

Cancelling at T=4527

Attempt 1 at T=72
Cancelling at T=587
Crash at 587
Attempt 2 at T=587
Cancelling at T=1089
Crash at 1090
Attempt 3 at T=1090
Cancelling at T=1291
3
End at T=1292

有趣的是，如果在 main 函数中同时调用两个函数的话，Cancelling at T=4527 是在调用 coroutineWay() 方法时打印出来的：尽管最后根本没有时间消耗，取消事件自身就浪费在无法停止的计算问题上，也因此在取消已经完成的任务上增加了额外消耗。

另一方面，RxJava 至少及时地取消和重试了函数。然而，实际上也有几乎没必要的 Cancelling at T=1291 被打印出来了。呐，没办法，写出来就这样了，或者说我懒吧，在 Single.timeout 中是这样实现的：如果没有延时就完成了的话，无论操作符真实情况如何，内部的 CompositeDisposable 代理了上游的 Disposable 并将其和操作符一起取消了。

结论

最后呢，我们通过一个小小的改进来看一下响应式设计的强大之处：如果只需要重试没有响应的函数的话，为什么我们要重试整个过程呢？改进方法也可以很容易地在 RxJava 中找到：将 doOnDispose().timeout().retry() 放到每一个函数调用链中（也许用 transfomer 可以避免代码的重复）：

val timeoutRetry = SingleTransformer<Int, Int> {
it.doOnDispose({
println(" Cancelling at T=" +
(System.currentTimeMillis() - t0))
})
.timeout(500, TimeUnit.MILLISECONDS)
.retry({ x, e ->
println(" Crash at " +
(System.currentTimeMillis() - t0))
x < 3 && e is TimeoutException
})
}

// …

Single.zip(
Single.fromCallable({ f3© })
.subscribeOn(Schedulers.io())
.compose(timeoutRetry)
,
Single.fromCallable({ f4© })
.subscribeOn(Schedulers.io())
.compose(timeoutRetry)
,
BiFunction<Int, Int> { a, b -> a + b }
)
// …
欢迎读者亲自动手实践并更新协程的实现来实现相同行为（顺便可以试试各种其他形式的取消机制）。响应式编程的好处之一是大多数情况下都不必去理会诸如线程、取消信息的传递和操作符的结构等恼人的东西。RxJava 之类的库已经设计好了 API 并将这些底层的大麻烦封装起来了，通常情况下，程序员只需要使用即可。
那么，协程到底有没有用呢？当然有用啦，但总的来说，我还是觉得性能对其是极大的限制，同时，我也想知道协程可以怎么做才能整体取代响应式编程。