Kotlin协程使用

什么是Kotlin协程

协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达，而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程（甚至不同机器）上调度执行，而代码则保持如同顺序执行一样简单。

协程就像非常轻量级的线程。线程是由系统调度的，线程切换或线程阻塞的开销都比较大。而协程依赖于线程，但是协程挂起时不需要阻塞线程，几乎是无代价的，协程是由开发者控制的。所以协程也像用户态的线程，非常轻量级，一个线程中可以创建任意个协程。

协程虽然不能脱离线程而运行，但可以在不同的线程之间切换。

协程的优势：

引用库

    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"

开启协程

runBlocking

    fun runBlocking() = runBlocking {
        repeat(5) {
            Log.i("minfo", "协程执行$it,当前线程id:${Thread.currentThread().id}")
            delay(1000)
        }
    }

runBlocking启动的协程任务会阻断当前线程，直到该协程执行结束。

2.launch

     fun runCoroutine() {
        Log.i("minfo", "协程开始")
        CoroutineScope(Dispatchers.Default).launch {
            delay(2000)
            Log.i("minfo", "协程内部")
        }
        Log.i("minfo", "协程下面")
    }

launch启动的协程不会阻断当前线程，协程体后面执行的代码仍会继续执行，不会受协程开启的影响。即我们主线程中的耗时操作可以开启协程到子线程中进行处理。

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

launch() 是CoroutineScope的一个扩展函数，CoroutineScope简单来说就是协程的作用范围。CoroutineScope.launch返回类型为Job类型。

取消协程

GlobalScope.launch返回对象job可直接调用cancel取消协程。

 job.cancel()

CoroutineScope

CoroutineScope即协程运行的作用域，主要作用是提供CoroutineContext，协程运行的上下文

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

我们常见的实现有GlobalScope,LifecycleScope,ViewModelScope等

协程下上文

协程是通过Dispatchers调度器来控制线程切换的。
上下文有一个重要的作用就是线程切换，Kotlin协程使用调度器来确定哪些线程用于协程执行，Kotlin提供了调度器给我们使用：

挂起函数

协程体是一个用suspend关键字修饰的一个无参，无返回值的函数类型。被suspend修饰的函数称为挂起函数,与之对应的是关键字resume。 Kotlin 的编译器检测到 suspend 关键字修饰的函数以后，会自动将挂起函数转换成带有 CallBack 的函数，在做完异步事件后，会通过回调通知回去。而调用挂起函数的协程体后面的代码，将不会继续执行，会等待挂起函数执行完成，再继续往下执行。协程本身也是挂起函数。

那我们写一个模拟切到子线程进行耗时操作：

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //开启一个协程，切换到主线程
        GlobalScope.launch(Dispatchers.Main) {
            tvContent.text = loadData()
        }
    }

    /**
     * 模拟访问接口获取接口数据
     */
    suspend fun loadData(): String {
        var response = ""
        withContext(Dispatchers.IO) {
            //子线程中模拟耗时操作
            for (i in 0..10000000) {

            }
            response = "response"
        }

        return response
    }

}

在launch开启的协程体里，执行loadData挂起方法，将协程挂起，协程中其后面的代码不会执行，只有等到loadData挂起结束恢复后才会执行。

async/await用于获取返回值处理：

    suspend fun loadData(): String {
        var response = ""
        withContext(Dispatchers.IO) {
            //子线程中模拟耗时操作
            for (i in 0..10000000) {

            }
            response = "response"
        }

        return response
    }

    suspend fun getResult(): String {
        var result = GlobalScope.async(Dispatchers.Main) {
            return@async loadData()
        }
        return result.await()
    }

        GlobalScope.launch(Dispatchers.Main) {
            Log.d("minfo", getResult())
        }

Retrofit结合协程请求网络例子：

Retrofit从2.6.0开始已经支持协程了，如果在网络请求框架中，引入Rxjava仅仅用来与Retrofit结合使用，那就太没有必要了。我们可以用协程来代替Rxjava这部分的功能。

这里是使用玩安卓的接口：https://www.wanandroid.com/banner/json

创建BaseResponse实体类基类：

open class BaseResponse<T> (var errorCode: Int = 0, var errorMsg: String = "", var data: T) : Serializable

在ApiService类中声明一个请求函数，声明为挂起函数，类型不需要添加Call。

interface ApiService {

    @GET("banner/json")
    suspend fun getFindData(): BaseResponse<List<DataBean>>
}

加入数据解析扩展函数：

fun <T> BaseResponse<T>.dataConvert(): T {
    if (errorCode == 0) {
        return data
    } else {
        throw Exception(errorMsg)
    }
}

object RetrofitServiceManager {
    private val okHttpClient: OkHttpClient
    private val retrofit: Retrofit

    private const val DEFAULT_CONNECT_TIME = 10
    private const val DEFAULT_WRITE_TIME = 30
    private const val DEFAULT_READ_TIME = 30
    private const val REQUEST_PATH = "https://www.wanandroid.com/"

    init {

        okHttpClient = OkHttpClient.Builder()
            .connectTimeout(DEFAULT_CONNECT_TIME.toLong(), TimeUnit.SECONDS)//连接超时时间
            .writeTimeout(DEFAULT_WRITE_TIME.toLong(), TimeUnit.SECONDS)//设置写操作超时时间
            .readTimeout(DEFAULT_READ_TIME.toLong(), TimeUnit.SECONDS)//设置读操作超时时间
            .build()

        retrofit = Retrofit.Builder()
            .client(okHttpClient)//设置使用okhttp网络请求
            .baseUrl(REQUEST_PATH)//设置服务器路径
            .addConverterFactory(GsonConverterFactory.create())//添加转化库，默认是Gson
            .build()

    }

    fun <T> create(service: Class<T>): T {
        return retrofit.create(service)
    }
}

创建viewModel类，使用viewModelScope开启协程:

class MyViewModel: ViewModel() {
    val items = ObservableArrayList<DataBean>()

    val itemBinding by lazy {
        ItemBinding.of<DataBean>(BR.item, R.layout.item).bindExtra(BR.viewModel, this)
    }

    init {
        getData()
    }

    private fun getData() {
        //viewModelScope是ViewModel的一个扩展函数，也是一个协程
        viewModelScope.launch {
            try {
                var dataBean =  RetrofitServiceManager.create(ApiService::class.java).getFindData().dataConvert()
                items.addAll(dataBean)
            } catch (e: Exception) {
                e.printStackTrace()
                Log.i("TAG", "${e.message}")
            }
        }
    }
}

使用ViewModel：

        var binding: ActivityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main)
        binding.lifecycleOwner = this
        binding.viewModel = viewModel

请求结果并显示在列表中：

使用viewModelScrope开启协程，viewModel生命周期与UI组件生命周期一致，父协程结束，那么所有子协程都会结束，就能避免了子协程中内存泄露的情况。

参考

Kotlin 协程看这一篇就够了
 Kotlin协程

协程实现原理——状态机

定义挂起函数

suspend fun requestLoadUser(id: String)

协程的挂起(suspend)和恢复(resume)：

反编译之后：

public final Object requestLoadUser(@NotNull String id, @NotNull Continuation $completion) {
      return "";
}

可以看到，多了个Continuation(继续)参数，这是个接口，是在本次函数执行完毕后执行的回调。

public interface Continuation<in T> {
    /**
     * 保存上下文(比如变量状态)
     */
    public val context: CoroutineContext
    /**
     * 方法执行结束的回调，参数是个泛型，用来传递方法执行的结果
     */
    public fun resumeWith(result: Result<T>)
}

suspend代码示例：

suspend fun getToken(id: String): String = "token"
suspend fun getInfo(token: String): String = "info"

// 添加了局部变量a，看下suspend怎么保存a这个变量
suspend fun test() {
    val token = getToken("123") // 挂起点1，这里是异步线程
    var a = 10 // 这里是10  //主线程
    val info = getInfo(token) // 挂起点2，需要将前面的数据保存(比如a)，在挂起点之后恢复   //异步线程
    println(info)  //主线程
    println(a
}

反编译之后：

public final Object getToken(String id, Continuation completion) {
    return "token";
}

public final Object getInfo(String token, Continuation completion) {
    return "info";
}

// 重点函数(伪代码)
public final Object test(Continuation<String>: continuation) {
    Continuation cont = new ContinuationImpl(continuation) {
        int label; // 保存状态
        Object result; // 保存中间结果，还记得那个Result<T>吗，是个泛型，因为泛型擦除，所以为Object，用到就强转
        int tempA; // 保存上下文a的值，这个是根据具体代码产生的
    };
    switch(cont.label) {
        case 0 : {
            cont.label = 1; //更新label
            
            getToken("123",cont) // 执行对应的操作，注意cont，就是传入的回调
            break;
        }

        case 1 : {
            cont.label = 2; // 更新label
            
            // 这是一个挂起点，我们要保存上下文数据，这里就保存a的值
            int a  = 10;
            cont.tempA = a; // 保存a的值 

            // 获取上一步的结果，因为泛型擦除，需要强转
            String token = (Object)cont.result;
            getInfo(token, cont); // 执行对应的操作
            break;
        }

        case 2 : {
            String info = (Object)cont.result; // 获取上一步的结果
            println(info); // 执行对应的操作

            // 在挂起点之后，恢复a的值
            int a = cont.tempA;
            println(a);

            return;
        }
    }
}

我们可以将每个case理解为一个状态，每个case分支对应的语句，理解为一个Continuation实现。
上述伪代码大致描述了协程的调度流程:

1 调用test函数时，需要传入一个Continuation接口，我们会对它进行二次装饰。
2 装饰就是根据函数具体逻辑，在内部添加额外的上下文数据和状态信息(也就是label)。
3 每个状态对应一个Continuation接口，里面会执行对应的业务逻辑。
4 每个状态都会: 保存上下文信息 -> 获取上一个状态的结果 -> 执行本状态业务逻辑 -> 恢复上下文信息。
5 直到最后一个状态对应的逻辑执行完毕。

总结：

1 Kotlin中，每个suspend方法，都需要一个Continuation接口实现，用来执行下一个状态的操作；并且，每个suspend方法的调用点都会产生一个挂起点。
2 每个挂起点，都会产生一个label，对应于状态机的一个状态，不同的状态之间，通过Continuation来切换。
3 Kotlin协程会在每个挂起点保存当前的上下文数据，并且在挂起点之后进行恢复。这样，每个状态之间就是相互独立的，可以独立调度。
4 协程的切换，只不过是从一种状态切换到另一种状态，因为不同状态是相互独立的，所以在合适的时机，再切换回来也不会对结果造成影响。

参考：https://www.modb.pro/db/211852

https://mp.weixin.qq.com/s/70wBBKwFFLb0X_zrsvNzDA

https://www.bilibili.com/video/BV1KJ41137E9/?spm_id_from=333.337.search-card.all.click&vd_source=40c24e77b23dc2e50de2b7c87c6fed59

https://mp.weixin.qq.com/s?__biz=MzA5MzI3NjE2MA==&mid=2650257918&idx=1&sn=0bde010f58df22508907e213980eb1d6&chksm=88634891bf14c187ac0ad10562c26476a6caf531ded0a772e4bd29bfae23f2accbcebbd04668&scene=27