kotlin 协程的使用2-一一网

这是我参与8月更文挑战的第11天，活动详情查看：8月更文挑战

RxJava与协程

网络请求，一般都会使用retrofit、rxjava、OKhttp等。首先不管用没用过，我们要明白这些东西是要来做什么的，其实retrofit和OKhttp基本一样，你可以理解为网络代理，就是你告诉它调用哪个接口，它返回你结果，至于过程，如果你没那个需要，不管也行。至于rxjava，可以理解为一个工具箱，主要用于多线程并发任务的管理，还有事件流。那先用rxjava实现网络请求怎么做？

interface GitHubApi {
    fun listReposRx(@Path("user")user:String): Single<List<Repo>>
}
复制代码

返回值修改为Single，就完成了api的修改了。

    private fun initRetrofit() {
        val okHttpClient = OkHttpClient.Builder().sslSocketFactory(
            TrustAllSSLSocketFactory.newInstance(),
            TrustAllSSLSocketFactory.TrustAllCertsManager()
        )
        retrofit = Retrofit.Builder()
            .baseUrl("https://api.github.com/")
            .client(okHttpClient.build())
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJava2CallAdapterFactory.createWithScheduler(Schedulers.io()))//使用rxjava是加上这一句
            .build()
        api = retrofit.create(GitHubApi::class.java)
    }
复制代码

同时初始化retrofit是，需要加上addCallAdapterFactory，这里我默认为全部的网络请求，都在io线程执行。

    private fun requestByRx() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            api.listReposRx("TonyDash")
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(object : SingleObserver<List<Repo>> {
                    override fun onSuccess(t: List<Repo>) {
                        textView.text = "Rx${t[0].name}"
                    }

                    override fun onSubscribe(d: Disposable) {
                        textView.text = "onSubscribe"
                    }

                    override fun onError(e: Throwable) {
                        textView.text = e.message?:"onError"
                    }
                })
        }
    }
复制代码

最后就是请求部分，大致上跟传统的回调方式类似，多的部分就是对于线程切换的指定，利用observeOn指定了结果再主线程执行，结果也同样是在回调方法中处理。这样一看感觉变化不大，但是如果有个需求，需要2个接口，把2个接口的结果显示出来呢？
如果不用rxjava，也能做，就是结果嵌套，在上一个接口的结果回调中，继续执行下一个接口的逻辑。这样的写法，看上去就相对的麻烦，而且不清晰。
如果使用协程，应该怎么写？

    private fun requestByKtAsync(){
        if (::retrofit.isInitialized && ::api.isInitialized) {
            GlobalScope.launch(Dispatchers.Main) {
                try {
                    val async1 = async { api.listReposKt("TonyDash") }
                    val async2 = async { api.listReposKt("TonyDash") }
                    textView.text = "${async1.await()[0].name} requestByKtAsync ${async2.await()[0].name}"
                }catch (e:Exception){
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
复制代码

这里可以看到，使用了async，这里的async其实也是一个协程，而await()就是把方法挂起了，等到2个请求都有结果了，再赋值给textview。
可以看到协程的优势是：简洁，去掉了回调；还有就是代码的写法上，相对的简单。
相同的地方就是：大家都可以切换线程；都不需要嵌套调用。

协程的缺点

我个人的观点，凡是越简单好用的，就等于别人帮你做了更多的事情，也就是说，性能损耗会大一些，例如suspend关键字，其实就是如何找回对应的线程进行处理逻辑，其实是一个复杂的过程，就会相对地有性能的损耗，但是这个损耗相比于协程带来的好处，我觉得可以忽略。
协程能必须使用try catch来捕捉异常，我个人觉得这里也算是一个小小的麻烦吧，不算缺点。

协程泄漏

还有一个常见的场景我们需要注意，我们的耗时操作都是维持一段时间的，那如果这段时间内，用户把activity关闭了，因为网络请求内部是一个活跃的线程，并且持有activity的对象，那这个就会造成内存泄漏。所以在不用的时候，我们应该把协程取消掉。

    private fun requestByKtAsync(){
        if (::retrofit.isInitialized && ::api.isInitialized) {
            jobKtAsync = GlobalScope.launch(Dispatchers.Main) {
                try {
                    val async1 = async { api.listReposKt("TonyDash") }
                    val async2 = async { api.listReposKt("TonyDash") }
                    textView.text = "${async1.await()[0].name} requestByKtAsync ${async2.await()[0].name}"
                }catch (e:Exception){
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
复制代码

    override fun onDestroy() {
        super.onDestroy()
        if (::jobKt.isInitialized){
            jobKt.cancel()
        }
        if (::jobKtAsync.isInitialized){
            jobKtAsync.cancel()
        }
    }
复制代码

CoroutineScope

上面的代码，一直用到都是GlobalScope.launch，我也说过GlobalScope其实一般用于调试，实际上不这么写,而且这样不方便管理，我们可以创建一个全局统一管理的协程，在ondestroy的时候，统一取消协程。

class PracticeActivity2 : AppCompatActivity() {
    ...
    private val mainScope = MainScope()
    ...
}
复制代码

    private fun requestByKtAsync(){
        if (::retrofit.isInitialized && ::api.isInitialized) {
            mainScope.launch(Dispatchers.Main) {
                try {
                    val async1 = async { api.listReposKt("TonyDash") }
                    val async2 = async { api.listReposKt("TonyDash") }
                    textView.text = "${async1.await()[0].name} requestByKtAsync ${async2.await()[0].name}"
                }catch (e:Exception){
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
复制代码

    override fun onDestroy() {
        super.onDestroy()
        mainScope.cancel()
    }
复制代码

除此之外，我们甚至能使用jetpack来更加方便地使用，利用ktx的扩展属性。

    // Lifecycles only (without ViewModel or LiveData)
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"
复制代码

    private fun requestByKt() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            lifecycleScope.launch(Dispatchers.Main) {
                try {
                    val repos = api.listReposKt("TonyDash")
                    textView.text = "KT${repos[0].name}"
                } catch (e: Exception) {
                    textView.text = e.message ?: "error"
                }
            }
        }
    }
复制代码