Kotlin 协程库v1.7.1的核心模块（kotlinx-coroutines-core）-- kotlinx.coroutines篇

asContextElement：

创建一个协程上下文元素(CoroutineContext.Element)，该元素可以被添加到协程上下文中，以便在特定的协程中检索和使用

注意：上下文元素不跟踪线程局部变量的修改
示例

val myThreadLocal = ThreadLocal<String?>()
println(myThreadLocal.get()) // 打印"null"
GlobalScope.launch(Dispatchers.Default + myThreadLocal.asContextElement(value = "foo")) {println(myThreadLocal.get()) // 打印“foo”withContext(Dispatchers.Main) {println(myThreadLocal.get()) // UI线程上 打印“foo”}
}
println(myThreadLocal.get())// 打印"null"

asCoroutineDispatcher：

将常规的java.util.concurrent.Executor 转换为 Kotlin 协程中的 CoroutineDispatcher，CoroutineDispatcher是协程中用于调度协程执行的抽象，它决定了协程运行在哪个线程或线程池中。
示例

// 创建一个固定大小的线程池
val executor = Executors.newFixedThreadPool(2)
// 将线程池转换为 CoroutineDispatcher
val dispatcher: CoroutineDispatcher = executor.asCoroutineDispatcher()
// 在指定的调度器上启动协程
runBlocking(dispatcher) {launch {println("Task 1 is running on ${Thread.currentThread().name}")}launch {println("Task 2 is running on ${Thread.currentThread().name}")}
}
// 关闭线程池
executor.shutdown()

js asDeferred：

将JavaScript中的Promise对象转换为Deferred类型
示例

runBlocking {val deferredResult = async {// 模拟一个异步操作delay(1000)
//        Async operation completed}// 将 Deferred 对象转换为 Deferred 类型val convertedDeferred: Deferred<String> = deferredResult.asDeferred()// 等待异步操作完成val result = convertedDeferred.await()println(result)
}

asExecutor：

将CoroutineDispatcher转换为Executor接口。这对于与使用Java的一些库和API集成时很有用，因为它们可能期望一个Executor而不是CoroutineDispatcher 示例

val dispatcher: CoroutineDispatcher = Dispatchers.Default// 使用asExecutor将CoroutineDispatcher转换为Executor
val executor: Executor = dispatcher.asExecutor()// 然后可以将其用于与期望Executor的Java库或API进行交互
val runnable = Runnable {println("Running on executor")
}executor.execute(runnable)

js asPromise：

Deferred对象转换为JavaScript中的Promise对象。主要用于与基于Promise的异步编程框架
示例

    suspend fun performAsyncTask(): String {// Simulate an asynchronous taskkotlinx.coroutines.delay(1000)return "Task completed"}fun main() {// Start an asynchronous task using asyncval asyncTask = lifecycleScope.async {performAsyncTask()}// Convert the async task to a Promiseval promise: Promise<String> = asyncTask.asPromise()// Handle the Promise in JavaScript-like stylepromise.then(onFulfilled = { result ->console.log("Promise resolved: $result")},onRejected = { reason ->console.error("Promise rejected: $reason")})// In a real application, you might want to wait for the Promise to complete// before exiting the program. This is just a simple example.}

async:

Kotlin 协程库提供的一个构建器，用于在协程中执行异步任务。它与 launch 不同，async 返回一个 Deferred 对象，该对象包含异步任务的结果这个就不写示例了上面示例有

js await：

毫无阻碍地等待承诺的完成。

awaitAll：

并发执行多个异步任务并等待它们全部完成。你可以使用async启动这些任务，然后使用awaitAll等待它们的完成。
示例

fun main() = runBlocking {val deferred1 = async { fetchDataFromNetwork1() }val deferred2 = async { fetchDataFromNetwork2() }// 等待两个异步任务完成val result = try {awaitAll(deferred1, deferred2)} catch (e: Exception) {// 处理异常}// 得到结果println(result)
}private suspend fun fetchDataFromNetwork1(): String {// 模拟从网络获取数据的异步操作delay(1000)return "Data from Network 1"
}private suspend fun fetchDataFromNetwork2(): String {// 模拟从网络获取数据的异步操作delay(1500)return "Data from Network 2"
}

awaitCancellation:

在协程中挂起，直到协程被取消。当协程被取消时，该函数将抛出CancellationException，而不是返回Nothing。
示例

fun main() = runBlocking {val job = launch {try {// 执行一些耗时任务repeat(1000) { i ->println("Task is running: $i")delay(500)}} finally {println("Task is cancelled")}}// 模拟一段时间后取消协程delay(2500)job.cancelAndJoin()// 这里的协程将一直挂起，直到它被取消awaitCancellation()
}Task is running: 0
Task is running: 1
Task is running: 2
Task is running: 3
Task is running: 4
Task is cancelled

cancel:

取消操作
示例

fun main() = runBlocking {val job = CoroutineScope(Dispatchers.Default).launch {try {// 在这里执行一些异步操作，例如网络请求或耗时计算withContext(Dispatchers.IO) {// 模拟一个耗时操作delay(1000)}// 在异步操作完成后执行一些操作println("Task completed successfully")} catch (e: CancellationException) {// 在取消时的处理println("Task was cancelled")}}//取消job.cancel()delay(5000)//防止跑完 还没打印Task was cancelled就停止了
}Task was cancelled

cancelAndJoin：

取消任务并挂起调用协程，直到取消的任务完成。示例

fun main() = runBlocking {val job = CoroutineScope(Dispatchers.IO).launch {try {// 模拟一个耗时的操作repeat(100) { index ->println("Coroutine is running: $index")delay(100)}} finally {// 协程完成或取消时执行的清理工作println("Coroutine cleanup")}}// 取消并等待协程完成job.cancelAndJoin()
}

cancelChildren：

取消指定协程的所有子协程示例

fun main() = runBlocking {startAsyncTasks()delay(1500)stopAsyncTasks()delay(10000)
}
private var parentJob: Job? = nullfun startAsyncTasks() {// 创建一个父协程作业parentJob = CoroutineScope(Dispatchers.IO).launch {try {// 启动多个子协程来执行异步任务val job1 = async { fetchDataFromNetwork1() }val job2 = async { fetchDataFromNetwork2() }// 等待所有子协程完成val awaitAll = awaitAll(job1, job2)// 所有任务完成后的操作// ...println(awaitAll)} catch (e: CancellationException) {// 当父协程被取消时，会进入此块// 可以在这里处理取消时的清理工作// ...println("Task was cancelled")}}
}fun stopAsyncTasks() {// 取消父协程的所有子协程parentJob?.cancelChildren()
}private suspend fun fetchDataFromNetwork1(): String {// 模拟从网络获取数据的异步操作delay(1000)return "Data from Network 1"
}private suspend fun fetchDataFromNetwork2(): String {// 模拟从网络获取数据的异步操作delay(3500)return "Data from Network 2"
}Task was cancelled

CancellableContinuation：

提供对协程取消的更细粒度控制，在协程执行期间能够检查和响应取消操作。

State	isActive	isCompleted	isCancelled
Active (initial state)	`true`	`false`	`false`
Resumed (final completed state)	`false`	`true`	`false`
Canceled (final completed state)	`false`	`true`	`true`

    +-----------+   resume    +---------+|  Active   | ----------> | Resumed |+-----------+             +---------+|| cancelV+-----------+| Cancelled |+-----------+

示例

fun main() = runBlocking{try {val result = withTimeout(5000) {// 模拟一个需要时间较长的操作performLongRunningOperation()}// 操作成功完成println("Operation result: $result")} catch (e: TimeoutCancellationException) {// 操作超时println("Operation timed out")}
}// 模拟一个需要时间较长的操作
private suspend fun performLongRunningOperation(): String = suspendCancellableCoroutine { continuation ->val job = GlobalScope.launch(Dispatchers.IO) {// 模拟一个长时间运行的任务delay(10000)println("任务完成")// 如果协程没有被取消，就恢复 continuationif (continuation.isActive) {println("isActive == ture")continuation.resume("Operation completed successfully"){println("resume ${it.message}")}}}// 注册一个取消回调，以便在协程被取消时取消这个任务continuation.invokeOnCancellation {println("invokeOnCancellation ${it?.message}")job.cancel()}
}

CancellationException：

取消异常

CloseableCoroutineDispatcher：

继承至CoroutineDispatcher额外提供了一个关闭它的方法，导致拒绝任何新任务，并清除与当前调度程序关联的所有底层资源
示例

class CustomDispatcher : CloseableCoroutineDispatcher() {// 自定义调度逻辑的实现override fun dispatch(context: CoroutineContext, block: Runnable) {// 在这里实现自定义的调度逻辑executor.submit {block.run()}}//原子操作private val closed = AtomicBoolean(false)override val executor: ExecutorServiceget() = Executors.newSingleThreadExecutor()override fun close() {if (closed.compareAndSet(false, true)) {// 在这里执行关闭资源的逻辑// 这个示例中简单地关闭线程池executor.shutdown()println("Closing resources...")}}
}fun main() = runBlocking {// 示例中使用自定义调度程序val customDispatcher = CustomDispatcher()customDispatcher.use { customDispatcher ->// 使用 withContext 指定自定义调度器withContext(customDispatcher) {// 在自定义调度器上执行异步任务println("Running on custom dispatcher - Thread: ${Thread.currentThread().name}")}}
}

CompletableDeferred：

CompletableDeferred 是 Kotlin 协程库中的一个类，用于表示异步操作的结果。它是 Deferred 的一个特殊实现，专注于没有返回值的异步操作（Completable Deferred，无返回值）。CompletableDeferred 有两个主要的函数：complete 和 await。

complete: 用于完成这个 CompletableDeferred，表示异步操作已经完成。
await: 用于等待异步操作完成，它是一个挂起函数，可以在协程中使用。

class MyAsyncTask {// 使用 CompletableDeferred 作为异步任务的结果private val completableDeferred = CompletableDeferred<Unit>()fun doAsyncTask() {// 在后台启动一个协程执行异步任务GlobalScope.launch {// 模拟异步任务的耗时操作simulateAsyncOperation()// 异步任务完成时调用 completecompletableDeferred.complete(Unit)}}suspend fun getResult() {// 等待异步任务完成completableDeferred.await()// 这里可以在主线程中处理异步任务完成后的逻辑}private suspend fun simulateAsyncOperation() {// 模拟异步操作的耗时println("In the consumption of time.")delay(3000)println("Time-consuming completion.")}
}fun main() = runBlocking {val myAsyncTask = MyAsyncTask()// 启动异步任务myAsyncTask.doAsyncTask()// 等待异步任务完成myAsyncTask.getResult()println("Async task completed.")
}In the consumption of time.
Time-consuming completion.
Async task completed.

CompletableJob:

CompletableJob 在 Job 的基础上添加了一些额外的功能，使得它更适合一些特定的使用场景。CompletableJob 允许你手动完成（complete 一个任务。在协程中，当你使用 launch、async 等构建器创建协程时，它们会返回一个 Job 对象。这个 Job 对象就是协程的引用，你可以使用这个引用来控制协程的生命周期。

    // 创建一个 CompletableJobval completableJob = Job()// 创建一个 CoroutineScope，并关联上面的 CompletableJobval coroutineScope = CoroutineScope(Dispatchers.Default + completableJob)// 启动一个协程val job = coroutineScope.launch {// 协程的逻辑delay(1000) // 模拟一些工作//任务完成时手动完成 jobcompletableJob.complete()// 任务完成后，可以执行一些操作println("Coroutine completed")}// 可以添加监听器来处理任务完成的事件completableJob.invokeOnCompletion {println("Job completed")// 可以在这里执行一些额外的操作}// 在主线程中等待协程完成runBlocking {//手动完成 jobjob.join()}Coroutine completed
Job completed

completeWith：

这个方法的作用是将将给定的 Result 对象的结果结果（成功或失败）传递给 CompletableDeferred。completeWith 返回一个布尔值，表示操作是否成功。如果 CompletableDeferred 已经被完成过，那么这个方法将返回 false。

runBlocking{val completableDeferred = CompletableDeferred<String>()// 在后台线程中模拟异步操作，并将结果传递给 CompletableDeferredGlobalScope.launch(Dispatchers.IO) {try {// 模拟异步操作成功，并将结果传递给 CompletableDeferredval result = Result.success("Operation completed successfully")completableDeferred.completeWith(result)} catch (e: Exception) {// 模拟异步操作失败，并将异常传递给 CompletableDeferredval result = Result.failure<String>(e)completableDeferred.completeWith(result)}}// 等待异步操作的结果val result = completableDeferred.await()// 打印结果println(result)}

CompletionHandler：

对于 Job.invokeOnCompletion 和 CancellableContinuation.invokeOnCancellation 的处理程序
安装的处理程序不应抛出任何异常。如果出现异常，它们将被捕获，封装成 CompletionHandlerException，并重新抛出，可能导致与无关的代码崩溃。传递给处理程序的 cause 的含义：

当任务正常完成时，cause 为 null。
当任务被正常取消时，cause 为 CancellationException。不应将其视为错误。特别是不应将其报告到错误日志中。
否则，任务失败。

注意：这种类型是支持父子层次结构并允许实现等待 Job 状态的挂起函数的内部机制的一部分。此类型不应在一般应用程序代码中使用。CompletionHandler 的实现必须快速且无锁。

val job = GlobalScope.launch {// 协程的代码delay(1000)throw RuntimeException("Async task failed")println("Coroutine completed")}// 设置协程完成时的处理程序job.invokeOnCompletion { cause ->when (cause) {null -> {println("Job completed successfully")}is CancellationException -> {println("Job was cancelled")}else -> {println("Job failed with exception: $cause")}}}// 等待协程完成runBlocking {job.join()}Exception in thread "DefaultDispatcher-worker-1" java.lang.RuntimeException: Exception while trying to handle coroutine exceptionat kotlinx.coroutines.CoroutineExceptionHandlerKt.handlerException(CoroutineExceptionHandler.kt:38)at kotlinx.coroutines.CoroutineExceptionHandlerImplKt.handleCoroutineExceptionImpl(CoroutineExceptionHandlerImpl.kt:52)at kotlinx.coroutines.CoroutineExceptionHandlerKt.handleCoroutineException(CoroutineExceptionHandler.kt:33)at kotlinx.coroutines.StandaloneCoroutine.handleJobException(Builders.common.kt:196)at kotlinx.coroutines.JobSupport.finalizeFinishingState(JobSupport.kt:229)at kotlinx.coroutines.JobSupport.tryMakeCompletingSlowPath(JobSupport.kt:906)at kotlinx.coroutines.JobSupport.tryMakeCompleting(JobSupport.kt:863)at kotlinx.coroutines.JobSupport.makeCompletingOnce$kotlinx_coroutines_core(JobSupport.kt:828)at kotlinx.coroutines.AbstractCoroutine.resumeWith(AbstractCoroutine.kt:100)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:46)at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)Suppressed: java.lang.RuntimeException: Async task failedat com.yang.myapplication.MainActivityKt$main$job$1.invokeSuspend(MainActivity.kt:65)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)... 5 more
Caused by: java.lang.NoClassDefFoundError: android/os/Build$VERSIONat kotlinx.coroutines.android.AndroidExceptionPreHandler.handleException(AndroidExceptionPreHandler.kt:47)at kotlinx.coroutines.CoroutineExceptionHandlerImplKt.handleCoroutineExceptionImpl(CoroutineExceptionHandlerImpl.kt:48)... 13 more
Caused by: java.lang.ClassNotFoundException: android.os.Build$VERSIONat java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)... 15 more
Exception in thread "DefaultDispatcher-worker-1" java.lang.RuntimeException: Async task failedat com.yang.myapplication.MainActivityKt$main$job$1.invokeSuspend(MainActivity.kt:65)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [StandaloneCoroutine{Cancelling}@6cb2c53e, Dispatchers.Default]
Job failed with exception: java.lang.RuntimeException: Async task failed

CoroutineDispatcher：

所有协程调度程序实现扩展的基类

以下是 CoroutineDispatcher 的一些标准实现，它们由 kotlinx.coroutines 提供，并作为 Dispatchers 对象的属性：

Dispatchers.Default:用于所有标准构建器，如果它们的上下文中没有指定调度器或任何其他 ContinuationInterceptor。使用一个共享的后台线程池，适用于消耗 CPU 资源的计算密集型协程。
Dispatchers.IO:使用一个共享的线程池，在需要时创建线程，设计用于处理 IO 密集型的阻塞操作（如文件 I/O 和阻塞的套接字 I/O）。
Dispatchers.Unconfined:在当前调用帧中启动协程执行，直到第一个挂起点，在那时协程构建器函数返回。协程将在稍后由相应的挂起函数使用的任何线程中恢复，而不限制在特定的线程或线程池中。Unconfined 调度器通常不应该在代码中使用。
私有线程池可以使用 newSingleThreadContext 和 newFixedThreadPoolContext 创建。
任意的 java.util.concurrent.Executor 可以使用 asCoroutineDispatcher 扩展函数转换为调度器。

在 Android 中，你可以使用这些调度器来指定协程的执行上下文，以便它们在适当的线程或线程池中运行，从而更好地管理并发和异步操作。

CoroutineName：

提供了一种在协程上下文中携带协程名字信息的方式，使得在调试和日志输出时能够更容易地追踪协程的执行。

// 在主线程启动一个协程runBlocking {// 在 IO 线程执行异步操作val result = withContext(Dispatchers.IO) {// 协程名字为 "IOOperation"val operationName = CoroutineName("IOOperation")// 在 IO 线程中携带协程名字val result = withContext(operationName + Dispatchers.IO) {// 执行一些耗时的 IO 操作"Result from IO operation"}// 打印协程名字println("Coroutine name: ${operationName.name}")result}// 打印异步操作的结果println("Result on Main thread: $result")}Coroutine name: IOOperation
Result on Main thread: Result from IO operation

coroutineScope：

另一种创建 CoroutineScope 并使用此范围调用挂起块的方式。它设计用于并发分解工作。提供的范围从外部范围继承其 coroutineContext，但覆盖上下文的 Job。如果此范围内的任何子协程失败，则此范围失败，其余的所有子协程都会被取消。

suspend fun showSomeData() = coroutineScope {val data = async(Dispatchers.IO) {// ... 为主线程加载一些 UI 数据 ...}withContext(Dispatchers.Main) {doSomeWork()val result = data.await()display(result)}
}

CoroutineStart：

CoroutineStart 是 Kotlin 协程库中用于协程启动的枚举类，它定义了在协程构建器（如 launch、async 等）中用作 start 参数的选项。以下是这些选项的简要概述：

DEFAULT：默认选项，会根据协程的上下文立即安排协程执行。
LAZY：懒启动选项，只有在需要的时候才启动协程。
ATOMIC：原子启动选项，在不可取消的方式下，根据协程的上下文立即安排协程执行。

UNDISPATCHED：无调度启动选项，会在当前线程中立即执行协程，直到遇到第一个挂起点。

runBlocking {// 示例：使用 DEFAULT 启动协程val job = GlobalScope.launch(start = CoroutineStart.DEFAULT) {println("Coroutine started")delay(1000)println("Coroutine completed")}job.join()// 示例：使用 LAZY 启动协程val lazyJob = GlobalScope.launch(start = CoroutineStart.LAZY) {println("Lazy Coroutine started")delay(1000)println("Lazy Coroutine completed")}lazyJob.start() // 手动启动lazyJob.join()// 示例：使用 ATOMIC 启动协程val atomicJob = GlobalScope.launch(start = CoroutineStart.ATOMIC) {println("Atomic Coroutine started")delay(1000)println("Atomic Coroutine completed")}atomicJob.join()// 示例：使用 UNDISPATCHED 启动协程val undispatchedJob = GlobalScope.launch(start = CoroutineStart.UNDISPATCHED) {println("Undispatched Coroutine started")delay(1000)println("Undispatched Coroutine completed")}undispatchedJob.join()
}

Deferred:

一种非阻塞的可取消 future。它是 Job 的子类，表示具有结果的任务。

fun main() = runBlocking {// 创建一个 Deferred 对象val deferred: Deferred<Int> = async {delay(1000) // 模拟耗时操作42 // 返回结果}// 在不阻塞线程的情况下等待 Deferred 完成，并获取结果val result: Int = deferred.await()println("Result: $result")
}Result: 42

delay：

提供的一个挂起函数，用于在协程中进行延迟操作，而不会阻塞线程。它有两个重载形式

suspend fun delay(timeMillis: Long)
suspend fun delay(duration: Duration)

这两个函数都能够将协程挂起一段时间，然后再继续执行。它们的作用是为了模拟暂停，而不是直接阻塞线程。

runBlocking {println("Start")delay(Duration.ofSeconds(1)) // 挂起协程 1 秒println("After delay")
}

Dispatchers：

参考CoroutineDispatcher

ensureActive:

确保当前协程仍然保持活跃状态，如果协程或作业不再活跃，它会抛出 CancellationException 异常。该函数提供了更精确的异常，因此你可以在协程内捕获 CancellationException，以便更好地处理取消的情况。

runBlocking {launch {try {// 模拟耗时操作repeat(1000) {// 确保协程仍处于活动状态ensureActive()// 一些工作println("Working $it")delay(100)}} catch (e: CancellationException) {// 在协程被取消时执行的代码println("Coroutine cancelled: ${e.message}")}}// 等待一段时间，然后取消协程delay(500)coroutineContext.cancelChildren()
}Working 0
Working 1
Working 2
Working 3
Working 4
Coroutine cancelled: StandaloneCoroutine was cancelled

`ensurePresent` ：

用于检查当前协程上下文中是否包含指定的 ThreadLocal 实例。如果该 ThreadLocal 不存在于协程上下文中，ensurePresent 会抛出 IllegalStateException。这有助于避免在协程中使用过时的或无效的 ThreadLocal 值，从而提高代码的健壮性

ExperimentalCoroutinesApi：

标记仍处于实验的coroutines API中，这意味着相应声明的设计存在公开的问题，这些问题可能会(也可能不会)导致它们在将来发生变化。粗略地说，这些声明有可能在不久的将来被弃用，或者它们行为的语义可能会以某种方式改变，这可能会破坏一些代码。

GlobalScope：

全局作用域用于启动顶级协程，这些协程在整个应用程序生命周期内运行，不会过早取消。请在有限的情况下合理安全地使用。

    @OptIn(DelicateCoroutinesApi::class)GlobalScope.launch {while (true) {delay(1000)println("GlobalScope run once")}}

handleCoroutineException：

介绍：为协程构建器的实现提供一个辅助函数，是为了防止异常丢失而设计的，是一种最后的手段。用于处理那些在协程中未捕获且不能通过正常方式（比如使用 try-catch）处理的异常。

runBlocking {val exceptionHandler = CoroutineExceptionHandler { _, exception ->println("Caught an exception: $exception")}// 在这里，我们故意抛出一个异常，但由于有异常处理器，异常将被捕获。val job = launch(exceptionHandler) {throw RuntimeException("Intentional exception")}job.join() // 等待作业完成}

invoke：

扩展函数，其作用是在指定的 CoroutineDispatcher 上调用给定的挂起块，并等待其完成，然后返回结果。

runBlocking {// 在 IO 线程上执行 fetchDataFromNetworkval networkData = Dispatchers.IO.invoke {fetchDataFromNetwork()}// 在默认的调度器上执行 fetchDataFromDiskval diskData = Dispatchers.Default.invoke {fetchDataFromDisk()}//2000+3000 后打印println("Network Data: $networkData")println("Disk Data: $diskData")
}Network Data: Data from network
Disk Data: Data from disk

IO：

Dispatchers.IO 是一个专门设计用于将阻塞 I/O 任务卸载到共享线程池的协程调度器

默认情况下，IO 线程池大小为 64。
Dispatchers.IO 具有独特的弹性特性。使用 CoroutineDispatcher.limitedParallelism 可以获取不受 Dispatchers.IO 并行性限制

isActive：

介绍：检查协程是否处于活动状态的属性

runBlocking {val job = launch {repeat(1000) { i ->// 检查协程是否仍处于活动状态if (!isActive) {println("Cancelling due to isActive = false")return@launch}println("I'm sleeping $i ...")delay(500L)}}delay(1300L) // 等待一段时间// 取消协程println("main: Cancelling the job!")job.cancelAndJoin()println("main: Quitting")//coroutineContext.isActive表达式是的快捷方式get(Job)?.isActive ?: true//while (coroutineContext.isActive) {//    do some computation//}
}I'm sleeping 0 ...
I'm sleeping 1 ...
I'm sleeping 2 ...
main: Cancelling the job!
main: Quitting

job:

是 Kotlin 协程中的一个关键概念，用于表示一个可以取消的、带有生命周期的任务

Cancellation（取消）： Job 可以被取消，用于中断任务的执行。取消一个 Job 会导致它的所有子 Job 也被递归地取消。
Hierarchy（层次结构）： Job 可以组成父子关系的层次结构，其中父 Job 的取消会立即取消所有子 Job。

状态管理： Job 有多个状态，包括 New、Active、Completing、Cancelling、Cancelled 和 Completed。这些状态反映了 Job 的生命周期。

State	isActive	isCompleted	isCancelled
New (optional initial state)	`false`	`false`	`false`
Active (default initial state)	`true`	`false`	`false`
Completing (transient state)	`true`	`false`	`false`
Cancelling (transient state)	`false`	`false`	`true`
Cancelled (final state)	`false`	`true`	`true`
Completed (final state)	`false`	`true`	`false`

Exception Handling（异常处理）：通过 Job，你可以处理任务执行过程中的异常，区分正常取消和异常取消。
Concurrency and synchronization（并发和同步）： Job 及其派生接口的所有函数都是线程安全的，可以从并发的协程中安全地调用，无需外部同步。

val job: Job = GlobalScope.launch {// 协程的执行逻辑delay(1000)println("Coroutine completed")}// 在这里，我们可以对协程进行取消// job.cancel()// 等待协程完成runBlocking {job.join()}

val job: CompletableJob = Job()GlobalScope.launch(job) {// 协程的执行逻辑delay(1000)println("Coroutine completed")}// 在这里，我们可以对协程进行取消// job.complete()// 等待协程完成runBlocking {job.join()}

joinAll：

用于挂起当前协程，直到传递的所有 Job 完成为止。这是一个方便的方法，可以等待多个协程的完成，而不必在代码中使用 job.join() 多次。

挂起当前协程直到所有给定的 Job 完成

runBlocking {val job1 = launch { /* 协程1的逻辑 */ }val job2 = launch { /* 协程2的逻辑 */ }val job3 = launch { /* 协程3的逻辑 */ }joinAll(job1, job2, job3)
}

挂起当前协程直到集合中的所有 Job 完成

runBlocking {val jobs = listOf(launch { /* 协程1的逻辑 */ },launch { /* 协程2的逻辑 */ },launch { /* 协程3的逻辑 */ })jobs.joinAll()
}

launch：

启动协程的一个函数

MainScope：

介绍：为UI组件创建主协同作用域我一般理解为Android的Activity协程作用域

class MyAndroidActivity {private val scope = MainScope()override fun onDestroy() {super.onDestroy()scope.cancel()}
}

NonCancellable：

一个特殊的 Job 对象，用于创建一个非可取消的协程。它是为了在某些代码块中防止被取消而设计的，通常与 withContext 函数一起使用。
注意：NonCancellable 并不是为了用在 launch、async 等协程构建器中的。如果你使用

launch(NonCancellable) { ... }

不仅新启动的任务不会在父任务被取消时取消，整个父子关系也会被切断。父任务将不等待子任务完成，也不会在子任务出现崩溃时被取消。

fun main() = runBlocking {val coroutineScope = CoroutineScope(Dispatchers.IO).launch {withContext(NonCancellable+Dispatchers.Default) {repeat(10){delay(1000)println("NonCancellable print $it")}}}coroutineScope.cancel()//防止整个线程退出 测试用delay(19000)
}NonCancellable print 0
NonCancellable print 1
NonCancellable print 2
NonCancellable print 3
NonCancellable print 4
NonCancellable print 5
NonCancellable print 6
NonCancellable print 7
NonCancellable print 8
NonCancellable print 9

plus：

扩展函数，它的作用是将指定的协程上下文（CoroutineContext）添加到当前协程作用域 (CoroutineScope) 中，并覆盖当前作用域上下文中的相应键。这是为了方便地创建一个新的协程作用域，其中包含了当前作用域的上下文以及额外添加的上下文。
比如上面“NonCancellable+Dispatchers.Default”

runBlocking：

运行一个新的协程阻碍当前线程，直到它完成。这个函数不应该在协程中使用。它旨在将常规的阻塞代码与以挂起方式编写的库连接起来，以便在main函数和测试中。

Runnable：

用于表示一个可以在异步环境中执行的任务。在 kotlinx.coroutines 中，这个接口被扩展，以支持协程调度

class MyRunnable : Runnable {override fun run() {println("Hello from Runnable!")}
}// 在协程中执行
fun main() = runBlocking {val runnable = MyRunnable()val dispatcher: CoroutineDispatcher = Dispatchers.Defaultdispatcher.dispatch(coroutineContext,runnable)
}Hello from Runnable!

SupervisorJob：

一种特殊类型的 Job，它用于创建协程的层级结构，其中子协程的失败不会影响其它子协程。这允许在协程的层级结构中灵活地处理失败。supervisor可以实施自定义策略来处理其子项的失败。
注意：不管如何父线程要是崩了子协程一样也是活不了的

launch创建的子协程，可以通过上下文中的CoroutineExceptionHandler来处理。（实施自定义策略）

async创建的子协程，可以通过Deferred.await对结果延迟值进行处理（也需要实施自定义策略不然结果返回一样崩）

 runBlocking{val supervisor = SupervisorJob(coroutineContext.job) // 创建一个 SupervisorJob 作为子协程val coroutineScope = CoroutineScope(supervisor) // 使用 supervisor 作为协程的 JobcoroutineScope.launch {// 执行一些操作delay(1000)println("Hello from SupervisorJob launch")throw RuntimeException("Child Coroutine 1 failed!")}coroutineScope.async {// 执行一些异步操作delay(1500)println("Hello from SupervisorJob async")}CoroutineScope(supervisor).launch{// 执行一些异步操作delay(100)println("Hello from launch1")//throw RuntimeException("lead to Parent Coroutine 1 failed!")delay(2000)println("Hello from launch2")}}//这玩意我放fun main 跑的时候居然一直在运行很奇怪Hello from launch1
Hello from SupervisorJob launch
Exception in thread "DefaultDispatcher-worker-2" java.lang.RuntimeException: Exception while trying to handle coroutine exceptionat kotlinx.coroutines.CoroutineExceptionHandlerKt.handlerException(CoroutineExceptionHandler.kt:38)at kotlinx.coroutines.CoroutineExceptionHandlerImplKt.handleCoroutineExceptionImpl(CoroutineExceptionHandlerImpl.kt:52)at kotlinx.coroutines.CoroutineExceptionHandlerKt.handleCoroutineException(CoroutineExceptionHandler.kt:33)at kotlinx.coroutines.StandaloneCoroutine.handleJobException(Builders.common.kt:196)at kotlinx.coroutines.JobSupport.finalizeFinishingState(JobSupport.kt:229)at kotlinx.coroutines.JobSupport.tryMakeCompletingSlowPath(JobSupport.kt:906)at kotlinx.coroutines.JobSupport.tryMakeCompleting(JobSupport.kt:863)at kotlinx.coroutines.JobSupport.makeCompletingOnce$kotlinx_coroutines_core(JobSupport.kt:828)at kotlinx.coroutines.AbstractCoroutine.resumeWith(AbstractCoroutine.kt:100)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:46)at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)Suppressed: java.lang.RuntimeException: Child Coroutine 1 failed!at com.yang.myapplication.MainActivityKt$main$1$1.invokeSuspend(MainActivity.kt:82)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)... 5 more
Caused by: java.lang.NoClassDefFoundError: android/os/Build$VERSIONat kotlinx.coroutines.android.AndroidExceptionPreHandler.handleException(AndroidExceptionPreHandler.kt:47)at kotlinx.coroutines.CoroutineExceptionHandlerImplKt.handleCoroutineExceptionImpl(CoroutineExceptionHandlerImpl.kt:48)... 13 more
Caused by: java.lang.ClassNotFoundException: android.os.Build$VERSIONat java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)... 15 more
Exception in thread "DefaultDispatcher-worker-2" java.lang.RuntimeException: Child Coroutine 1 failed!at com.yang.myapplication.MainActivityKt$main$1$1.invokeSuspend(MainActivity.kt:82)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.kt:570)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [StandaloneCoroutine{Cancelling}@3ca7b389, Dispatchers.Default]
Hello from SupervisorJob async
Hello from launch2

supervisorScope：

快捷的创建上述SupervisorJob

runBlocking{supervisorScope {launch {delay(1000)println("Hello from SupervisorJob launch")throw RuntimeException("Child Coroutine 1 failed!")}async {delay(1500)println("Hello from SupervisorJob async")}launch {delay(2000)println("Hello from SupervisorJob launch")}}launch{delay(2500)println("Hello from launch2")coroutineContext.job.cancel()}}Hello from SupervisorJob launch
Exception in thread "main" java.lang.RuntimeException: Exception while trying to handle coroutine exceptionat kotlinx.coroutines.CoroutineExceptionHandlerKt.handlerException(CoroutineExceptionHandler.kt:38)at kotlinx.coroutines.CoroutineExceptionHandlerImplKt.handleCoroutineExceptionImpl(CoroutineExceptionHandlerImpl.kt:52)at kotlinx.coroutines.CoroutineExceptionHandlerKt.handleCoroutineException(CoroutineExceptionHandler.kt:33)at kotlinx.coroutines.StandaloneCoroutine.handleJobException(Builders.common.kt:196)at kotlinx.coroutines.JobSupport.finalizeFinishingState(JobSupport.kt:229)at kotlinx.coroutines.JobSupport.tryMakeCompletingSlowPath(JobSupport.kt:906)at kotlinx.coroutines.JobSupport.tryMakeCompleting(JobSupport.kt:863)at kotlinx.coroutines.JobSupport.makeCompletingOnce$kotlinx_coroutines_core(JobSupport.kt:828)at kotlinx.coroutines.AbstractCoroutine.resumeWith(AbstractCoroutine.kt:100)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:46)at kotlinx.coroutines.DispatchedTaskKt.resume(DispatchedTask.kt:234)at kotlinx.coroutines.DispatchedTaskKt.dispatch(DispatchedTask.kt:166)at kotlinx.coroutines.CancellableContinuationImpl.dispatchResume(CancellableContinuationImpl.kt:397)at kotlinx.coroutines.CancellableContinuationImpl.resumeImpl(CancellableContinuationImpl.kt:431)at kotlinx.coroutines.CancellableContinuationImpl.resumeImpl$default(CancellableContinuationImpl.kt:420)at kotlinx.coroutines.CancellableContinuationImpl.resumeUndispatched(CancellableContinuationImpl.kt:518)at kotlinx.coroutines.EventLoopImplBase$DelayedResumeTask.run(EventLoop.common.kt:500)at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.common.kt:284)at kotlinx.coroutines.BlockingCoroutine.joinBlocking(Builders.kt:85)at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking(Builders.kt:59)at kotlinx.coroutines.BuildersKt.runBlocking(Unknown Source)at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking$default(Builders.kt:38)at kotlinx.coroutines.BuildersKt.runBlocking$default(Unknown Source)at com.yang.myapplication.MainActivityKt.main(MainActivity.kt:74)at com.yang.myapplication.MainActivityKt.main(MainActivity.kt)Suppressed: java.lang.RuntimeException: Child Coroutine 1 failed!at com.yang.myapplication.MainActivityKt$main$1$1$1.invokeSuspend(MainActivity.kt:79)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)... 15 more
Caused by: java.lang.NoClassDefFoundError: android/os/Build$VERSIONat kotlinx.coroutines.android.AndroidExceptionPreHandler.handleException(AndroidExceptionPreHandler.kt:47)at kotlinx.coroutines.CoroutineExceptionHandlerImplKt.handleCoroutineExceptionImpl(CoroutineExceptionHandlerImpl.kt:48)... 23 more
Caused by: java.lang.ClassNotFoundException: android.os.Build$VERSIONat java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)... 25 more
Exception in thread "main" java.lang.RuntimeException: Child Coroutine 1 failed!at com.yang.myapplication.MainActivityKt$main$1$1$1.invokeSuspend(MainActivity.kt:79)at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)at kotlinx.coroutines.DispatchedTaskKt.resume(DispatchedTask.kt:234)at kotlinx.coroutines.DispatchedTaskKt.dispatch(DispatchedTask.kt:166)at kotlinx.coroutines.CancellableContinuationImpl.dispatchResume(CancellableContinuationImpl.kt:397)at kotlinx.coroutines.CancellableContinuationImpl.resumeImpl(CancellableContinuationImpl.kt:431)at kotlinx.coroutines.CancellableContinuationImpl.resumeImpl$default(CancellableContinuationImpl.kt:420)at kotlinx.coroutines.CancellableContinuationImpl.resumeUndispatched(CancellableContinuationImpl.kt:518)at kotlinx.coroutines.EventLoopImplBase$DelayedResumeTask.run(EventLoop.common.kt:500)at kotlinx.coroutines.EventLoopImplBase.processNextEvent(EventLoop.common.kt:284)at kotlinx.coroutines.BlockingCoroutine.joinBlocking(Builders.kt:85)at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking(Builders.kt:59)at kotlinx.coroutines.BuildersKt.runBlocking(Unknown Source)at kotlinx.coroutines.BuildersKt__BuildersKt.runBlocking$default(Builders.kt:38)at kotlinx.coroutines.BuildersKt.runBlocking$default(Unknown Source)at com.yang.myapplication.MainActivityKt.main(MainActivity.kt:74)at com.yang.myapplication.MainActivityKt.main(MainActivity.kt)Suppressed: kotlinx.coroutines.DiagnosticCoroutineContextException: [StandaloneCoroutine{Cancelling}@58701e8c, BlockingEventLoop@951461a]
Hello from SupervisorJob async
Hello from SupervisorJob launch
Hello from launch2

suspendCancellableCoroutine：

一个用于支持协程挂起的函数。它的主要作用是允许你在协程中等待一个单次回调的结果，并将结果返回给调用方。它提供了对取消的支持，确保在协程取消时及时清理资源。

val mockApi = MockApi()suspend fun awaitCallback() = suspendCancellableCoroutine { continuation ->val callback = object : Callback {override fun onCompleted(value: String) {println("onCompleted $value")// 用回调提供的值恢复协程continuation.resume(value)}override fun onApiError(cause: Throwable) {// 用回调提供的异常恢复协程continuation.resumeWithException(cause)}}mockApi.register(callback)continuation.invokeOnCancellation{mockApi.unregister(callback)}
}class MockApi : Api {private var callback: Callback? = nulloverride fun register(callback: Callback) {this.callback = callback}override fun unregister(callback: Callback) {// 在取消时注销回调this.callback = null}fun triggerCallback(value: String) {runBlocking {delay(2000)println("Send Completed")callback?.onCompleted(value)}}fun triggerError(cause: Throwable) {runBlocking {delay(2000)println("Send ApiError")callback?.onApiError(cause)}}
}interface Api {fun register(callback: Callback)fun unregister(callback: Callback)
}interface Callback {fun onCompleted(value: String)fun onApiError(cause: Throwable)
}// 在协程中执行
fun main():Unit =runBlocking{//开个子协程launch {try {val result = awaitCallback()println("Callback completed with result: $result")} catch (e: Throwable) {println("Callback failed with exception: $e")}//等待回调的结果返回完成 继续执行println("Continue to perform the task ")}// 模拟成功的回调mockApi.triggerCallback("Success!")//mockApi.triggerError(Throwable("Error"))
}Send Completed
onCompleted Success!
Callback completed with result: Success!
Continue to perform the task

withContext：

在不同的协程上下文中执行挂起函数。它的作用是在指定的协程上下文中执行一个挂起函数块，并在该块执行完成后返回结果

suspend fun exampleFunction() = withContext(Dispatchers.IO) {// 在 IO 线程中执行耗时操作，例如网络请求或文件 I/Odelay(1000) // 模拟耗时操作return@withContext "Result from withContext"
}fun main() = runBlocking {val result = exampleFunction()println(result)
}Result from withContext

withTimeout ：

挂起函数并在设置超时时间，如果超过了指定的时间，将抛出 TimeoutCancellationException 异常。这有助于在异步操作中设置超时，防止长时间等待或阻塞。

suspend fun performAsyncTask(): String {delay(3000) // 模拟一个耗时的异步任务return "Task completed successfully!"
}fun performBlockingTask(): String {Thread.sleep(3000) // 模拟一个阻塞任务 return "Blocking task completed successfully!"
}fun main() = runBlocking {try {val result = withTimeout(2000) {performAsyncTask()//performBlockingTask()}println(result)} catch (e: TimeoutCancellationException) {println("Task timed out!")}
}Task timed out!
//Blocking task completed successfully!

withTimeoutOrNull ：

在协程中设置超时。它的作用是在指定的时间内运行一个挂起的代码块，并在超时时返回 null，而不是抛出异常。
超时会导致代码块内正在执行的代码被取消，并且在代码块内部激活或下一次激活可取消的挂起函数时，会抛出 TimeoutCancellationException 异常

runBlocking {val result = withTimeoutOrNull(3000) {// 在此处执行可能耗时的操作delay(5000) // 模拟一个长时间的操作"Operation completed"}if (result != null) {println("Success: $result")} else {println("Timeout occurred")}
}Timeout occurred

yield：

将当前协程的执行权交出，让同一调度器上的其他协程有机会执行。它是一种协作式多任务处理的机制，允许协程在不阻塞线程的情况下进行切换。

suspend fun launchWorker() = CoroutineScope(Dispatchers.Default).launch{repeat(10) {println("Worker coroutine is working $it")delay(50)// 使用 yield 让出执行权yield()}
}fun main() = runBlocking {val job = launchWorker()// 主协程做一些其他事情repeat(5) {println("Main coroutine is doing some work $it")delay(100)}// 等待工作协程完成job.cancel()
}Main coroutine is doing some work 0
Worker coroutine is working 0
Worker coroutine is working 1
Main coroutine is doing some work 1
Worker coroutine is working 2
Worker coroutine is working 3
Main coroutine is doing some work 2
Worker coroutine is working 4
Worker coroutine is working 5
Main coroutine is doing some work 3
Worker coroutine is working 6
Main coroutine is doing some work 4
Worker coroutine is working 7
Worker coroutine is working 8
Worker coroutine is working 9