Kotlin 协程学习总结

Kotlin 基础精华篇
 Kotlin 内联函数let、with、run、apply、also
Kotlin 协程学习总结

一、协程的使用与说明

        val job = GlobalScope.launch(
            context = Dispatchers.Default,
            start = CoroutineStart.DEFAULT,
            block = {
                val result1 = doTask("1", 2000)
                val result2 = async { doTask("1", 2000) }
                withContext(Dispatchers.Main) {
                    logMessage("result is ${result1}, ${result2.await()}")
                }
            }
        )

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
}

1、CoroutineScope

协程范围，即协程内的代码运行的时间周期范围，如果超出了指定的协程范围，协程会被取消执行。

CoroutineScope
协程范围接口
CoroutineContext:协程的上下文

public interface CoroutineScope {
    /**
     * The context of this scope.
     * Context is encapsulated by the scope and used for implementation of coroutine builders that are extensions on the scope.
     * Accessing this property in general code is not recommended for any purposes except accessing the [Job] instance for advanced usages.
     *
     * By convention, should contain an instance of a [job][Job] to enforce structured concurrency.
     */
    public val coroutineContext: CoroutineContext
}

ContextScope
协程范围实现类

internal class ContextScope(context: CoroutineContext) : CoroutineScope

GlobalScope
全局作用域，实现了 CoroutineScope接口同时执行了一个空的上下文对象的协程作用域。
其创建的协程没有父协程，通常用于启动顶级协程，这些协程在整个应用程序生命周期内运行。
直接使用 GlobalScope 的 async 或者 launch 方法是强烈不建议的。程序代码通常应该使用自定义的协程作用域。

MainScope
实现了 CoroutineScope接口同时是通过调度器调度到了主线程的协程作用域

public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main)

如：

class TestLifecycleActivity : AppCompatActivity(), CoroutineScope by MainScope() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.test_fargment)
        testCoroutine()
    }

    private fun testCoroutine() {
        logMessage("launchBefore")
        launch {
            //do task
            logMessage("taskBefore")
            val result1 = async { doTask("1", 20 * 1000) }
            val result2 = async { doTask("2", 20 * 1000) }
            val result3 = doTask("3", result1.await() + result2.await())
            logMessage("taskAfter")

            //切换主线程输出结果
            withContext(Dispatchers.Main) {
                logMessage("result is ${result1.await()}, ${result2.await()}, $result3")
            }
        }
        logMessage("launchAfter")
    }

    override fun onDestroy() {
        super.onDestroy()
        logMessage("onDestroy - cancel")
        cancel()
    }

    //...
}

日志输出：
    E/Coroutine: 16:49:50 983 *** ThreadName : main *** launchBefore
    E/Coroutine: 16:49:50 994 *** ThreadName : main *** launchAfter
    E/Coroutine: 16:49:51 243 *** ThreadName : main *** taskBefore
    E/Coroutine: 16:50:02 029 *** ThreadName : main *** onDestroy - cancel

自定义CoroutineScope

private val customScope = CoroutineScope(Dispatchers.IO + SupervisorJob())

viewModelScope
添加如下依赖：

def lifecycle_version = "2.2.0"
implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$lifecycle_version"

使用：

class TestViewModel : androidx.lifecycle.ViewModel() {
    fun testCoroutine() {
        viewModelScope.launch {
            //do task
        }
    }
}

而viewModelScope是怎么定义的呢

/**
 * [CoroutineScope] tied to this [ViewModel].
 * This scope will be canceled when ViewModel will be cleared, i.e [ViewModel.onCleared] is called
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
 */
val ViewModel.viewModelScope: CoroutineScope
        get() {
            val scope: CoroutineScope? = this.getTag(JOB_KEY)
            if (scope != null) {
                return scope
            }
            return setTagIfAbsent(JOB_KEY,
                CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate))
        }

lifecycleScope
添加如下依赖：

def lifecycle_version = "2.2.0"
implementation "androidx.lifecycle:lifecycle-runtime-ktx:$lifecycle_version"

使用：

        lifecycleScope.launch {  }
        lifecycleScope.launchWhenCreated {  }
        lifecycleScope.launchWhenResumed {  }
        lifecycleScope.launchWhenStarted {  }

viewModelScope是怎么定义的呢


/**
 * [CoroutineScope] tied to this [LifecycleOwner]'s [Lifecycle].
 *
 * This scope will be cancelled when the [Lifecycle] is destroyed.
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate].
 */
val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
    get() = lifecycle.coroutineScope


/**
 * [CoroutineScope] tied to this [Lifecycle].
 *
 * This scope will be cancelled when the [Lifecycle] is destroyed.
 *
 * This scope is bound to
 * [Dispatchers.Main.immediate][kotlinx.coroutines.MainCoroutineDispatcher.immediate]
 */
val Lifecycle.coroutineScope: LifecycleCoroutineScope
    get() {
        while (true) {
            val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl?
            if (existing != null) {
                return existing
            }
            val newScope = LifecycleCoroutineScopeImpl(
                this,
                SupervisorJob() + Dispatchers.Main.immediate
            )
            if (mInternalScopeRef.compareAndSet(null, newScope)) {
                newScope.register()
                return newScope
            }
        }
    }

2、launch

是CoroutineScope的一个扩展函数。
默认启动通过launch启动一个协程的时候包含一个继承自作用域的CoroutineContext，和一个默认的启动模式，调度器和要执行的协程体，之后返回一个Job。同时内部的job将成为外部job 的子job，当一个父协程被取消的时候，所有它的子协程也会被递归的取消。

lauch 与 runBlocking 都能开启一个协程，但 lauch 是非阻塞的，runBlocking 是阻塞的。

runBlocking中调用launch()会在当前线程中执行协程，也就是说在runBlocking中不管开启多少个子协程，实际上它们都是使用runBlocking所在的线程执行任务，所以会出现线程被霸占的情况。

        runBlocking {
            GlobalScope.launch {
                //do task
                logMessage("taskBefore")
                val result1 = async { doTask("1", 1000) }
                val result2 = async { doTask("2", 1000) }
                val result3 = doTask("3", result1.await() + result2.await())
                logMessage("taskAfter")
            }
        }

日志输出：（都在main线程顺序执行）
    E/Coroutine: 19:42:37 140 *** ThreadName : main *** launchBefore
    E/Coroutine: 19:42:37 157 *** ThreadName : main *** taskBefore
    E/Coroutine: 19:42:38 164 *** ThreadName : main *** task1 - 1000
    E/Coroutine: 19:42:38 166 *** ThreadName : main *** task2 - 1000
    E/Coroutine: 19:42:40 168 *** ThreadName : main *** task3 - 2000
    E/Coroutine: 19:42:40 168 *** ThreadName : main *** taskAfter

3、CoroutineContext

协程上下文，可以指定协程运行的线程。
默认与指定的CoroutineScope中的coroutineContext保持一致，比如GlobalScope默认运行在一个后台工作线程内。也可以通过显示指定参数来更改协程运行的线程，Dispatchers提供了几个值可以指定：Dispatchers.Default、Dispatchers.Main、Dispatchers.IO、Dispatchers.Unconfined。

Dispatchers.Default
CPU密集型任务，如列表排序、JSON转换等

Dispatchers.Main
主线程，和UI交互，执行轻量任务

Dispatchers.IO
常用于网络请求和文件访问

Dispatchers.Unconfined
不限制任何制定线程，一般不用

4、CoroutineStart

协程的启动模式。
默认CoroutineStart.DEFAULT是指协程立即执行，除此之外还有CoroutineStart.LAZY、CoroutineStart.ATOMIC、CoroutineStart.UNDISPATCHED。

CoroutineStart.DEFAULT
立即执行协程体

CoroutineStart.LAZY
懒汉式启动。launch后并不会有任何调度行为，协程体也不会进入执行状态，直到需要它执行的时候，即需要它的运行结果的时候，launch调用后会返回一个 Job实例：
调用 Job.start，主动触发协程的调度执行
调用 Job.join，隐式的触发协程的调度执行

CoroutineStart.ATOMIC
立即执行协程体，但在开始运行后无法取消，无视 job.cancel()

CoroutineStart.UNDISPATCHED
立即在当前线程执行协程体，直到第一个 suspend 调用。
协程在这种模式下会直接开始在当前线程下执行，直到第一个挂起点，这听起来有点儿像前面的 ATOMIC，不同之处在于 UNDISPATCHED 不经过任何调度器即开始执行协程体。当然遇到挂起点之后的执行就取决于挂起点本身的逻辑以及上下文当中的调度器了。

5、block

协程主体，也就是要在协程内部运行的代码。

6、Job

返回值，对当前创建的协程的引用。可以通过Job的start、cancel、join等方法来控制协程的启动和取消。

isActive 协程是否存活(注意懒启动)
isCancelled 协程是否取消
isCompleted 协程是否完成
cancel() 取消协程
start() 启动协程
join() 阻塞等候协程完成
cancelAndJoin() 取消并等候协程完成handler: CompletionHandler) 监听协程的状态回调
attachChild(child: ChildJob) 附加一个子协程到当前协程上

7、async、await

是CoroutineScope的一个扩展函数，用于开启一个新的子协程，与 launch 函数一样可以设置启动模式，不同的是它的返回值为 Deferred，Deferred是Job的子类，但是通过Deferred.await()可以得到一个返回值。

await() 只有在 async 未执行完成返回结果时，才会挂起协程。若 async 已经有结果了，await() 则直接获取其结果并赋值给变量，此时不会挂起协程。

8、suspend

suspend fun 挂起函数，即该函数是一个耗时操作，须放在协程中执行。

挂起函数只能在协程中和其他挂起函数中调用，不能在其他地方使用。

suspend函数会将整个协程挂起，而不仅仅是这个suspend函数，也就是说一个协程中有多个挂起函数时，它们是顺序执行的。

9、withContext

withContext 与 async 都可以返回耗时任务的执行结果。通常也会使用withContext实现线程切换。

一般来说，多个 withContext 任务是串行的，且withContext 可直接返回耗时任务的结果。多个 async 任务是并行的，async 返回的是一个Deferred<T>，需要调用其await()方法获取结果。

二、协程的执行测试

两个辅助方法

    private suspend fun doTask(msg: String, delayTime: Long = 0) =
        (if (delayTime < 1000) (1000 + Math.random() * 1000).toLong() else delayTime).apply {
            //延时
            delay(this)
            logMessage("task$msg - $this")
        }

    private fun logMessage(msg: String) {
        currentTime.time = System.currentTimeMillis()
        //日志输出当前时间、线程名、自定义信息
        Log.e(
            "Coroutine",
            "${dateFormat.format(currentTime)} *** ThreadName : ${Thread.currentThread().name} *** $msg"
        )
    }

1、顺序执行：task3依赖task2的结果，task2依赖task1的结果

    private fun testCoroutine() {
        logMessage("launchBefore")
        GlobalScope.launch {
            //do task
            logMessage("taskBefore")
            val result1 = doTask("1")
            val result2 = doTask("2", result1 - 1000)
            val result3 = doTask("3", result2 - 1000)
            logMessage("taskAfter")
            //输出结果
            withContext(Dispatchers.Main) {
                logMessage("result is ${result1}, ${result2}, $result3")
            }
        }
        logMessage("launchAfter")
    }

日志输出:
    E/Coroutine: 11:26:57 530 *** ThreadName : main *** launchBefore
    E/Coroutine: 11:26:57 590 *** ThreadName : main *** launchAfter
    E/Coroutine: 11:26:57 591 *** ThreadName : DefaultDispatcher-worker-1 *** taskBefore
    E/Coroutine: 11:26:59 475 *** ThreadName : DefaultDispatcher-worker-1 *** task1 - 1876
    E/Coroutine: 11:27:01 413 *** ThreadName : DefaultDispatcher-worker-1 *** task2 - 1936
    E/Coroutine: 11:27:03 386 *** ThreadName : DefaultDispatcher-worker-1 *** task3 - 1971
    E/Coroutine: 11:27:03 386 *** ThreadName : DefaultDispatcher-worker-1 *** taskAfter
    E/Coroutine: 11:27:03 394 *** ThreadName : main *** result is 1876, 1936, 1971

由以上日志输出可知：

协程 launch 中执行耗时任务没有阻塞主线程（launchAfter先于协程输出）
task1、task2、task3 顺序执行 (执行时间时间线)

2、异步执行：task3依赖task1、task2的结果，task1、task2异步执行

    private fun testCoroutine() {
        logMessage("launchBefore")
        GlobalScope.launch {
            //do task
            logMessage("taskBefore")
            val result1 = async { doTask("1", 2000) }
            val result2 = async { doTask("2", 2000) }
            val result3 = doTask("3", result1.await() + result2.await())
            logMessage("taskAfter")
            //输出结果
            withContext(Dispatchers.Main) {
                logMessage("result is ${result1.await()}, ${result2.await()}, $result3")
            }
        }
        logMessage("launchAfter")
    }

日志输出:
    E/Coroutine: 12:22:50 202 *** ThreadName : main *** launchBefore
    E/Coroutine: 12:22:50 264 *** ThreadName : main *** launchAfter
    E/Coroutine: 12:22:50 266 *** ThreadName : DefaultDispatcher-worker-1 *** taskBefore
    E/Coroutine: 12:22:52 279 *** ThreadName : DefaultDispatcher-worker-2 *** task1 - 2000
    E/Coroutine: 12:22:52 279 *** ThreadName : DefaultDispatcher-worker-3 *** task2 - 2000
    E/Coroutine: 12:22:56 282 *** ThreadName : DefaultDispatcher-worker-2 *** task3 - 4000
    E/Coroutine: 12:22:56 283 *** ThreadName : DefaultDispatcher-worker-2 *** taskAfter
    E/Coroutine: 12:22:56 290 *** ThreadName : main *** result is 2000, 2000, 4000

async { } 异步执行
await() 获取异步执行结果