Android协程的使用

网络请求

现在比较流行的网络框架，就是retrofit，而且retrofit从2.6版本开始，实现了对协程的支持，其实可以理解为retrofit对suspend关键字的支持。
以前如果是使用retrofit来实现网络请求，一般都有这么几个步骤：1、初始化retrofit 2、初始化Api代理接口 3、请求并在回调中处理结果

    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())
            .build()
        api = retrofit.create(GitHubApi::class.java)
    }

interface GitHubApi {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user")user:String):Call<List<Repo>>
}


    private fun requestByNormal() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            api.listRepos("TonyDash")
                .enqueue(object : Callback<List<Repo>> {
                    override fun onFailure(call: Call<List<Repo>>, t: Throwable) {
                        textView.text = "requestByNormal onFailure"
                    }

                    override fun onResponse(
                        call: Call<List<Repo>>,
                        response: Response<List<Repo>>
                    ) {
                        textView.text = response.body()?.get(0)?.name
                    }

                })
        }
    }

这样就完成了一次网络请求了。那如果使用协程的话，需要怎么实现呢？其实，在上面的基础上稍作修改，就可以变成协程，初始化retrofit部分不需要改动，先改api接口的定义：

interface GitHubApi {
    @GET("users/{user}/repos")
    fun listRepos(@Path("user")user:String):Call<List<Repo>>
    @GET("users/{user}/repos")
    suspend fun listReposKt(@Path("user")user:String):List<Repo>
}

listRepoKt就是支持协程的api，可以看到，区别就只有方法的前面多了一个suspend关键字，suspend的作用就是标记这个为挂起函数。最后来看请求部分：

    private fun requestByKt() {
        if (::retrofit.isInitialized && ::api.isInitialized) {
            GlobalScope.launch(Dispatchers.Main) {
                val repos = api.listReposKt("TonyDash")
                textView.text ="KT${repos[0].name}"
            }
        }
    }

这样就利用协程完成了一次网络请求了。可以明显看到，在请求数据的部分，少了回调，只需要肉眼看上去的按顺序写，就完成了异线程执行网络请求并主线程更新UI控件的工作，单个请求可能感觉差异不大，但是如果有一个需求你必须请求多个接口，并且多个接口还是有因果关系的，那就会有一种回调地狱的感觉，而且后期维护起来也相对麻烦，万一忘了以前是为什么这么写的呢？还有如果细心的话可以发现，利用回调处理结果的请求方法，有一个onFailure来处理请求的异常情况，那协程呢？协程怎么处理异常，下面我们单独讲。

异常处理

使用try catch来捕捉异常，由于kotlin取消了check exception机制，所以要捕捉异常，我们只能使用try catch来捕捉协程内的异常。

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

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"
                }
            }
        }
    }

这样使用lifecycleScope来启动协程，甚至连ondestroy中都不需要我们手动去取消协程，因为kotlin已经帮我们做了。另外ktx还有一些方便的api方法给我们使用，例如launchWhenCreated、launchWhenResumed、launchWhenStarted等。

image.png

总结：

协程和线程分别是什么？
对于kotlin for android而言，协程就是一个线程的框架，用于处理并发任务的。
协程和线程的优缺点？
优势：好用、简洁、去掉了回调使得逻辑清晰，而且自动切换线程。
缺点：相对的新，需要学习成本

例子demo：https://github.com/TonyDash/coroutines.git