开发语言 android Kotlin 协程库v1.7.1的核心模块（kotlinx-coroutines-core）-- kotlinx.coroutines篇

asContextElement：

asCoroutineDispatcher：

js asDeferred：

asExecutor：

js asPromise：

async:

js await：

awaitAll：

awaitCancellation:

cancelAndJoin：

cancelChildren：

CancellableContinuation：

CancellationException：

CloseableCoroutineDispatcher：

CompletableDeferred：

CompletableJob:

completeWith：

CompletionHandler：

CoroutineDispatcher：

CoroutineName：

coroutineScope：

CoroutineStart：

Deferred:

delay：

Dispatchers：

ensureActive:

ensurePresent ：

ExperimentalCoroutinesApi：

GlobalScope：

handleCoroutineException：

invoke：

IO：

isActive：

job:

joinAll：

launch：

MainScope：

NonCancellable：

plus：

runBlocking：

Runnable：

SupervisorJob：

supervisorScope：

suspendCancellableCoroutine：

withContext：

withTimeout ：

withTimeoutOrNull ：

yield：

asContextElement：

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

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

val myThreadLocal = ThreadLocal()

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 = 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 task

kotlinx.coroutines.delay(1000)

return "Task completed"

}

fun main() {

// Start an asynchronous task using async

val asyncTask = lifecycleScope.async {

performAsyncTask()

}

// Convert the async task to a Promise

val promise: Promise = asyncTask.asPromise()

// Handle the Promise in JavaScript-like style

promise.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? = null

fun 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：

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

StateisActiveisCompletedisCancelledActive (initial state)truefalsefalseResumed (final completed state)falsetruefalseCanceled (final completed state)falsetruetrue

+-----------+ resume +---------+

| Active | ----------> | Resumed |

+-----------+ +---------+

| cancel

+-----------+

| 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("任务完成")

// 如果协程没有被取消，就恢复 continuation

if (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: ExecutorService

get() = 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()

fun doAsyncTask() {

// 在后台启动一个协程执行异步任务

GlobalScope.launch {

// 模拟异步任务的耗时操作

simulateAsyncOperation()

// 异步任务完成时调用 complete

completableDeferred.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 对象就是协程的引用，你可以使用这个引用来控制协程的生命周期。

// 创建一个 CompletableJob

val completableJob = Job()

// 创建一个 CoroutineScope，并关联上面的 CompletableJob

val coroutineScope = CoroutineScope(Dispatchers.Default + completableJob)

// 启动一个协程

val job = coroutineScope.launch {

// 协程的逻辑

delay(1000) // 模拟一些工作

//任务完成时手动完成 job

completableJob.complete()

// 任务完成后，可以执行一些操作

println("Coroutine completed")

}

// 可以添加监听器来处理任务完成的事件

completableJob.invokeOnCompletion {

println("Job completed")

// 可以在这里执行一些额外的操作

}

// 在主线程中等待协程完成

runBlocking {

//手动完成 job

job.join()

}

Coroutine completed

Job completed

completeWith：

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

runBlocking{

val completableDeferred = CompletableDeferred()

// 在后台线程中模拟异步操作，并将结果传递给 CompletableDeferred

GlobalScope.launch(Dispatchers.IO) {

try {

// 模拟异步操作成功，并将结果传递给 CompletableDeferred

val result = Result.success("Operation completed successfully")

completableDeferred.completeWith(result)

} catch (e: Exception) {

// 模拟异步操作失败，并将异常传递给 CompletableDeferred

val result = Result.failure(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 exception

at 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 failed

at 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$VERSION

at 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$VERSION

at 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 failed

at 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 = 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 线程上执行 fetchDataFromNetwork

val networkData = Dispatchers.IO.invoke {

fetchDataFromNetwork()

}

// 在默认的调度器上执行 fetchDataFromDisk

val 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 的生命周期。

StateisActiveisCompletedisCancelledNew (optional initial state)falsefalsefalseActive (default initial state)truefalsefalseCompleting (transient state)truefalsefalseCancelling (transient state)falsefalsetrueCancelled (final state)falsetruetrueCompleted (final state)falsetruefalseException 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.Default

dispatcher.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 作为协程的 Job

coroutineScope.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 exception