目录
- 协程的用法
- 协程同步异步请求与Rxjava，原生写法的区别与优势
- 对于协程的理解
1.协程的用法
在安卓中添加引用，引用里面也包括了协程核心库
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.5'
接下来我们做三个网络请求实验，fetchData（）方法是一个网络请求，handleDataOnUI（）方法是一个主线程UI方法。
1.这里我们把方法放在GlobalScope.launch当中，指定Dispatchers.Main,即里面的代码将在主线程中执行
2.我们准备了三个网络请求,api1 api2 api3, 其中api2是一个耗时的网络请求,用来区分是否网络请求是有序发出还是并发
3.为async,withContext的方法指定了不同的Dispatchers.IO线程
//实验1,通过log日志可以看出,这三个网络请求是有序的，一个完成在请求另一个，等待全部完成执行最后
GlobalScope.launch(Dispatchers.Main) {
val data1 = async(Dispatchers.IO) { fetchData(1, api1) }.await()
val data2 = async(Dispatchers.IO) { fetchData(2, api2) }.await()
val data3 = async(Dispatchers.IO) { fetchData(3, api3) }.await()
handleDataOnUI(data1!!, data2!!, data3!!)
}
实验一.png
//实验2,通过log日志可以看出,这三个网络请求也是有序的
GlobalScope.launch(Dispatchers.Main) {
val data1 = withContext(Dispatchers.IO) { fetchData(1, api1) }
val data2 = withContext(Dispatchers.IO) { fetchData(2, api2) }
val data3 = withContext(Dispatchers.IO) { fetchData(3, api3) }
handleDataOnUI(data1!!, data2!!, data3!!)
}
实验二.png
//实验3,通过log日志可以看出,终于这三个网络请求是并发的
GlobalScope.launch(Dispatchers.Main) {
val data1 = async(Dispatchers.IO) { fetchData(1, api1) }
val data2 = async(Dispatchers.IO) { fetchData(2, api2) }
val data3 = async(Dispatchers.IO) { fetchData(3, api3) }
handleDataOnUI(data1.await()!!, data2.await()!!, data3.await()!!)
}
实验三.png
- 通过上面实验可以得出结论，无论网络请求是顺序执行的，还是并发执行的，都是执行完毕所有网络请求以后，才最终去处理handleDataOnUI()的方法。通过协程，就能做到这么简洁的写发。
原因分析
- 为什么会造成，不同的写法，一种是有序而另一种方式并发的呢？
1.首先我们看withContext(),这是一个suspend函数，通过api我们可以看到，当执行这个方法时，会阻塞当前block代码块，也就是下一行withContext()函数不会开始，直到当前方法结束
* Calls the specified suspending block with a given coroutine context, suspends until it completes, and returns
* the result.
public suspend fun <T> withContext(
context: CoroutineContext,
block: suspend CoroutineScope.() -> T
): T = suspendCoroutineUninterceptedOrReturn sc@ { uCont ->
//.....
2.接着我们看async函数，它实际上返回的是Deferred对象，并不会阻塞当前block函数。但是Deferred对象有一个await（）函数，我们看下具体定义。我们可以看到，这里await()同样是一个susupend函数，等待结果。有点类似于Java当中的Future模式，等待但是并不阻塞，直到结果返回在再次唤醒。
/**
* Awaits for completion of this value without blocking a thread and resumes when deferred computation is complete,
* returning the resulting value or throwing the corresponding exception if the deferred was cancelled.
*
* This suspending function is cancellable.
* If the [Job] of the current coroutine is cancelled or completed while this suspending function is waiting, this function
* immediately resumes with [CancellationException].
*
* This function can be used in [select] invocation with [onAwait] clause.
* Use [isCompleted] to check for completion of this deferred value without waiting.
*/
public suspend fun await(): T
3.总而言之，如果想要并发请求，我们必须要用async，如果是顺序执行，我们则可以使用withContext, 没必要使用async
//并发执行的正确写法
val task1 = async(Dispatcher.io){ doSomeStuff}
val task2 = async(Dispatcher.io){ doSomeStuff}
task1.await()
task2.await()
//顺序执行的常规写法
val task1 = withContext(Dispatcher.io){ doSomeStuff}
val task2 = withContext(Dispatcher.io){ doSomeStuff}
task1.await()
task2.await()
//或者
val task1 = async(Dispatcher.io){ doSomeStuff}.await()
val task2 = async(Dispatcher.io){ doSomeStuff}.await()
val total= task1+task2
2.协程同步异步请求与Rxjava，原生写法的区别与优势
- rxjava实现多个有序网络请求，因为rxjava是上游依次往下游发送事件，所以很容易写顺序请求
Observable.create(object : ObservableOnSubscribe<String> {
override fun subscribe(emitter: ObservableEmitter<String>?) {
emitter!!.onNext("url")
emitter!!.onComplete()
}
}).map(object : Function<String, String> {
override fun apply(t: String?): String {
val data1 = fetchData(1, api1)
return data1!!;
}
}).map(object : Function<String, String> {
override fun apply(t: String?): String {
val data2 = fetchData(2, api2)
return "[======$t][----$data2]"
}
}).subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe({ next ->
Log.d(TAG, next)
}, { error ->
error.printStackTrace()
})
- rxjava实现多个并发网络请求，我们可以用zip
Observable.zip(getObservable(1, api1), getObservable(2, api2),
getObservable(3, api3), object : Function3<String, String, String, String> {
override fun apply(t1: String?, t2: String?, t3: String?): String {
return t1 + t2 + t3
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(object : Observer<String> {
override fun onComplete() {
Log.d(TAG, "Observer onComplete")
}
override fun onSubscribe(d: Disposable?) {
Log.d(TAG, "Observer onSubscribe")
}
override fun onNext(t: String?) {
Log.d(TAG, "Observer onNext $t")
}
override fun onError(e: Throwable?) {
Log.d(TAG, "Observer onError")
}
})
- 如果用原生代码实现的话，这里就简单说下思路
1.顺序请求，不停接口回调即可实现
2.并发请求，多个线程并发执行，维护一个数组判断每个任务执行状态，在每个线程结束时，以同步的方式去检测和更新数组，如果全部执行完毕，则任务结束。
总之就是，协程对于多个并发网络请求，确实能够简写代码，方便使用和处理。
3.对于协程的理解
协程的用法有很多，我这也是简单的了解了基本的用法。协程更像是一个封装好的多线程请求框架，在安卓里面能更加方便切换线程，又能做到顺序和并发的网络请求，确实大大方便了网络请求的开发书写，但是对于网络请求中的失败，无网络等错误状态。还需要进一步学习和研究。对于协程的核心原理，更多是对底层java 多线程，线程池的封装，也有java Future模式的影子...
参考
https://www.kotlincn.net/docs/reference/coroutines/basics.html
https://stackoverflow.com/questions/52369508/kotlin-coroutines-async-await-sequence
https://blog.mindorks.com/mastering-kotlin-coroutines-in-android-step-by-step-guide
concurrent-using-async
网友评论