kotlin 协程 lanch 详解

@[TOC](kotlin 协程 lanch 详解)

---

前言

使用纯代码 加 注释的方式，可以更快的理解源码
如果你喜欢，请点个赞，后期会不断的深入讲解

---

一、协程是什么？

1.大部分开发者们把协程比喻成：线程的封装框架，从宏观角度看，这有一定道理
2.协程有点像轻量级的线程
3.从包含关系上看，协程跟线程的关系，有点像“线程与进程的关系”，毕竟，协程不可能脱离线程运行
4.协程虽然不能脱离线程而运行，但可以在不同的线程之间切换

二、传统方式完成异步网络加载和协程的对比

2.1：传统方式完成异步任务网络加载

接下来通过一个接口的模拟登录，来实现一下传统方式的步任务网络加载登录场景

代码如下：LoginRegisterResponseWrapper

data class LoginRegisterResponseWrapper<T>(val data: T, val errorCode: Int, val errorMsg: String)

代码如下：LoginRegisterResponse

data class LoginRegisterResponse(    val admin: Boolean,    val chapterTops: List<*>,    val collectIds: List<*>,    val email: String?,    val icon: String?,    val id: String?,    val nickname: String?,    val password: String?,    val publicName: String?,    val token: String?,    val type: Int,    val username: String?)

定义一个接口 代码如下：WanAndroidAPI

interface WanAndroidAPI {// TODO 下面是传统方式API    /** https://www.wanandroid.com/blog/show/2 * 登录API * username=Derry-vip&password=123456 */    @POST("/user/login")    @FormUrlEncoded    fun loginAction(        @Field("username") username: String,        @Field("password") password: String    )            : Call<LoginRegisterResponseWrapper<LoginRegisterResponse>>   // 返回值}

接口的实现 代码如下：APIClient

class APIClient {    /** * 单例 */    private object Holder {        val INSTANCE = APIClient()    }    companion object {    // 派生        val instance = Holder.INSTANCE    }    fun <T> instanceRetrofit(apiInstance: Class<T>): T {// OkHttpClient 请求服务器        val mOkHttpClient = OkHttpClient().newBuilder().apply {            readTimeout(10000, TimeUnit.SECONDS)     //添加超时时间            connectTimeout(10000, TimeUnit.SECONDS)   //添加连接超时时间            writeTimeout(10000, TimeUnit.SECONDS)    // 添加写入超时时间        }.build()        val retrofit = Retrofit.Builder()            .baseUrl("https://www.wanandroid.com")            // 请求方 ←            .client(mOkHttpClient)            // 响应方 →            // Response的事情 回来            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())     // RxJava来处理            .addConverterFactory(GsonConverterFactory.create())            // Gson 来解析 --- JavaBean            .build()        return retrofit.create(apiInstance)    }}

XML 代码如下

<?xml version="1.0" encoding="utf-8"?><androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"    xmlns:app="http://schemas.android.com/apk/res-auto"    xmlns:tools="http://schemas.android.com/tools"    android:layout_width="match_parent"    android:layout_height="match_parent"    tools:context=".ui.MainActivity">    <TextView        android:id="@+id/textview"        android:text="启动线程"        android:layout_width="match_parent"        android:layout_height="wrap_content"        tools:ignore="MissingConstraints" />    <Button        android:id="@+id/button"        android:onClick="startRequest"        android:layout_width="wrap_content"        android:layout_height="wrap_content"        android:text="网络请求"        app:layout_constraintBottom_toBottomOf="parent"        app:layout_constraintLeft_toLeftOf="parent"        app:layout_constraintRight_toRightOf="parent"        app:layout_constraintTop_toTopOf="parent"        tools:ignore="OnClick" /></androidx.constraintlayout.widget.ConstraintLayout>

具体功能实现，直接看代码吧，注释比较多
代码如下： MainActivity

class MainActivity : AppCompatActivity() {   private var mProgressDialog: ProgressDialog? = null    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_main)    }    fun startRequest(view: View){        mProgressDialog = ProgressDialog(this)        mProgressDialog?.setTitle("请求服务器中...")        mProgressDialog?.show()// TODO 第一步：异步线程开启，请求服务器        object: Thread(){            override fun run() {                super.run()                Thread.sleep(2000)   // 模拟一个两秒的加载时间                val loginResult = APIClient.instance.instanceRetrofit(WanAndroidAPI::class.java)                    .loginAction("Derry-vip", "123456")                val result: LoginRegisterResponseWrapper<LoginRegisterResponse>? = loginResult.execute().body()// 切换到主线程， 更新UI 把最终的javaBean 发送给Handler                val msg = mHandler.obtainMessage()                msg.obj = result                mHandler.sendMessage(msg)            }        }.start()    }    // TODO 第二步：主线程更新UI    val mHandler = Handler(Looper.getMainLooper()){// as 类型转换        val result = it.obj as LoginRegisterResponseWrapper<LoginRegisterResponse>        textview.text = result.data.toString()   // 更新控件 UI        mProgressDialog?.hide()        false    }}

上面的代码实现，是传统完成的异步加载操作。需要先开启一个异步线程，然后再把登录成功的数据，再交给主线线程去做UI的更新操作。

2.2：协程方式完成异步任务网络加载

再来实现一个协程的

修改 WanAndroidAPI 里面的接口，添加 suspend 关键字，代码如下：

    @POST("/user/login")    @FormUrlEncoded    suspend fun loginActionCoroutine(        @Field("username") username: String,        @Field("password") password: String    )            : LoginRegisterResponseWrapper<LoginRegisterResponse>  // 返回值

修改 MainActivity 中的代码，代码如下：

class MainActivity1 : AppCompatActivity() {    private var mProgressDialog: ProgressDialog? = null    private val main = MainScope()    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_main)    }    fun startRequest(view: View) {        mProgressDialog = ProgressDialog(this)        mProgressDialog?.setTitle("请求服务器中...")        mProgressDialog?.show()// launch 在Android 中使用的时候，它默认的是 IO 线程，所以需要修改成Main 线程 （Dispatchers.Main ）        main.launch(Dispatchers.Main) {            // 1.挂起出去执行异步线程 2. 操作完成之后，恢复主线程            val result = APIClient.instance.instanceRetrofit(WanAndroidAPI::class.java)                .loginActionCoroutine("Derry-vip", "123456")// 更新UI            textview.text = result.data.toString()            mProgressDialog?.hide()        }    }    override fun onDestroy() {        super.onDestroy()        main.cancel()    }}

是不是简单了很多呢？不再需要创建异步线程，然后再交给主线程去修改UI，而是直接使用 launch 挂起出去执行异步操作，操作完成后直接恢复到主线程

这只是一个简单的一层回调的例子，可以想象一些，如果老板让我们实现一个三层回调，30层回调的时候，我们使用传统的处理方式会有多疼苦，接下来我们来实现一下。

2.3：传统方式完成三层回调

先写个回调接口 代码如下 ResponseCallback

/** * 模拟请求服务器后，相应结果信息 */interface ResponseCallback {    /** * 请求服务器 加载成功 */    fun responseSuccess(serverResponseInfo: String)    /** * 请求服务器 加载失败 */    fun responseError(serverResponseErrorMsg: String)}

再写三个模拟数据请求的异步线程 代码如下：

/** * 第一层 * 请求加载 [用户数据] * * responseCallback [回调给外界的接口] */private fun requestLoadUser(responseCallback: ResponseCallback) {    val isLoadSuccess = true        // 加载成功 或 失败的标记    object : Thread() {        override fun run() {            super.run()            try {                sleep(3000L)     // 模拟请求 所造成的耗时                if (isLoadSuccess) {                    responseCallback.responseSuccess("加载到[用户数据]信息集")                } else {                    responseCallback.responseSuccess("加载[用户数据],加载失败,服务器宕机了")                }            } catch (e: InstantiationException) {                e.printStackTrace()            }        }    }.start()}/** * 第二层 * 请求加载 [用户资产数据] * * responseCallback [回调给外界的接口] */private fun requestLoadUserAssets(responseCallback: ResponseCallback) {    val isLoadSuccess = true        // 加载成功 或 失败的标记    object : Thread() {        override fun run() {            super.run()            try {                sleep(3000L)                if (isLoadSuccess) {                    responseCallback.responseSuccess("加载到[用户资产数据]信息集")                } else {                    responseCallback.responseError("加载[用户资产数据],加载失败,服务器宕机了")                }            } catch (e: InstantiationException) {                e.printStackTrace()            }        }    }.start()}/** * 第三层 * 请求加载 [用户资产详情数据] * * responseCallback [回调给外界的接口] */private fun requestLoadUserAssetsDetails(responseCallback: ResponseCallback) {    val isLoadSuccess = true        // 加载成功 或 失败的标记    object : Thread() {        override fun run() {            super.run()            try {                sleep(3000L)                if (isLoadSuccess) {                    responseCallback.responseSuccess("加载到[用户资产数据]信息集")                } else {                    responseCallback.responseError("加载[用户资产数据],加载失败,服务器宕机了")                }            } catch (e: InstantiationException) {                e.printStackTrace()            }        }    }.start()}

具体功能实现，直接看代码吧，没什么好讲的
代码如下： MainActivity

class MainActivity2 : AppCompatActivity() {    private var mProgressDialog: ProgressDialog? = null    private val main = MainScope()    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_main)    }    fun startRequest(view: View) {        mProgressDialog = ProgressDialog(this)        mProgressDialog?.setTitle("请求服务器中...")        mProgressDialog?.show()// TODO 先执行 异步请求 1        requestLoadUser(object : ResponseCallback {            override fun responseSuccess(serverResponseInfo: String) {// 从异步 切换到主线程，更新UI                val handler = object : Handler(Looper.getMainLooper()) {                    override fun handleMessage(msg: Message) {                        super.handleMessage(msg)                        textview.text = serverResponseInfo                        textview.setTextColor(Color.GRAY)// TODO 先执行 异步请求 2                        requestLoadUserAssets(object : ResponseCallback {                            override fun responseSuccess(serverResponseInfo: String) {                                val handler = object : Handler(Looper.getMainLooper()) {                                    override fun handleMessage(msg: Message) {                                        super.handleMessage(msg)                                        textview.text = serverResponseInfo                                        textview.setTextColor(Color.RED)                                        // TODO 先执行 异步请求 3                                        requestLoadUserAssetsDetails(object : ResponseCallback {                                            override fun responseSuccess(serverResponseInfo: String) {                                                val handler =                                                    object : Handler(Looper.getMainLooper()) {                                                        override fun handleMessage(msg: Message) {                                                            super.handleMessage(msg)                                                            textview.text = serverResponseInfo                                                            textview.setTextColor(Color.BLUE)                                                            mProgressDialog?.hide()                                                        }                                                    }                                                handler.sendEmptyMessage(0)                                            }                                            override fun responseError(serverResponseErrorMsg: String) {// TODO 失败的的逻辑就不写了                                            }                                        })                                    }                                }                                handler.sendEmptyMessage(0)                            }                            override fun responseError(serverResponseErrorMsg: String) {// TODO 失败的的逻辑就不写了                            }                        })                    }                }                handler.sendEmptyMessage(0)            }            override fun responseError(serverResponseErrorMsg: String) {// TODO 失败的的逻辑就不写了            }        })    }}

无限嵌套，让我想起了flutter 中的嵌套陷阱。
再看一下 使用协程 实现的三层回调

2.4：协程方式解决三层回调带

先定义三个方法，分别开启一个异步线程。 代码如下：

/** * 请求加载[用户数据] * * suspend 就是一个提醒的作用，提醒用户，当前函数是挂起的函数，可能执行异常操作 */private suspend fun requestLoadUser(): String{    val isLoadSuccess = true // 加载成功，和，加载失败，的标记// 此协程能够保证在异步执行    withContext(Dispatchers.IO){        delay(3000)     //模拟请求服务器，造成的耗时    }    if (isLoadSuccess){        return "加载到[用户数据]信息集"    }else{        return "加载[用户数据],加载失败,服务器宕机了"    }}/** * 请求加载[用户资产数据] */private suspend fun requestLoadUserAssets(): String{    val isLoadSuccess = true // 加载成功，和，加载失败，的标记// 此协程能够保证在异步执行    withContext(Dispatchers.IO){        delay(3000)     //模拟请求服务器，造成的耗时    }    if (isLoadSuccess){        return "加载到[用户资产数据]信息集"    }else{        return "加载[用户资产数据],加载失败,服务器宕机了"    }}/** * 请求加载[用户资产详情数据] */private suspend fun requestLoadUserAssetsDetails(): String{    val isLoadSuccess = true // 加载成功，和，加载失败，的标记// 此协程能够保证在异步执行    withContext(Dispatchers.IO){        delay(3000)     //模拟请求服务器，造成的耗时    }    if (isLoadSuccess){        return "加载到[用户资产详情数据]信息集"    }else{        return "加载[用户资产详情数据],加载失败,服务器宕机了"    }}

MainActivity 代码具体实现如下：

class MainActivity : AppCompatActivity() {    private var mProgressDialog: ProgressDialog? = null    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_main)    }    fun startRequest(view: View) {        mProgressDialog = ProgressDialog(this)        mProgressDialog?.setTitle("请求服务器中...")        mProgressDialog?.show()// Dispatchers.Main 包裹一层 Handler 切换主线程        GlobalScope.launch(Dispatchers.Main) {// TODO 先执行 异步请求1            var serverResponseInfo = requestLoadUser()            textview.text = serverResponseInfo    // 更新UI            textview.setTextColor(Color.YELLOW)   // 更新UI// TODO 更新UI完成后 异步请求2            serverResponseInfo = requestLoadUserAssets()            textview.text = serverResponseInfo    // 更新UI            textview.setTextColor(Color.RED)   // 更新UI// TODO 更新UI完成后 异步请求3            serverResponseInfo = requestLoadUserAssetsDetails()            textview.text = serverResponseInfo    // 更新UI            textview.setTextColor(Color.BLUE)   // 更新UI            mProgressDialog?.hide()        }    }}

看到这里，是不是发现很简单呢？

---

总结

难道协程很 ”高效“，”轻量“我们就要用协程吗？
答：其实协程的真正魅力是，最大程度简化异步并发任务，用同步代码写出异步效果

🤩
$\textcolor{blue}{原创不易，还希望各位大佬支持一下}$

$\textcolor{green}{点赞，你的认可是我创作的动力！}$

$\textcolor{green}{收藏，你的青睐是我努力的方向！}$

️ $\textcolor{green}{评论，你的意见是我进步的财富！}$