编辑“︁Kotlin协程上下文”︁（章节）

= Kotlin协程上下文 =

== 介绍 ==
'''Kotlin协程上下文'''（Coroutine Context）是协程运行时的环境配置，它定义了协程的行为和属性。上下文由多个元素（Element）组成，每个元素负责不同的功能，例如调度器（Dispatcher）、异常处理器（CoroutineExceptionHandler）或协程名称（CoroutineName）。上下文通过组合这些元素来为协程提供完整的运行时信息。

在Kotlin中，协程上下文是一个类型为 <code>CoroutineContext</code> 的接口，它使用键值对（Key-Value）结构存储元素。上下文可以通过运算符 <code>+</code> 进行组合，形成新的上下文。

== 上下文元素 ==
协程上下文的主要元素包括：
* '''Dispatcher'''：决定协程在哪个线程或线程池上运行。
* '''Job'''：表示协程的生命周期，可用于取消或等待协程完成。
* '''CoroutineName'''：为协程命名，便于调试。
* '''CoroutineExceptionHandler'''：处理协程内部的未捕获异常。

以下是一个简单的上下文组合示例：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*

fun main() = runBlocking {
    val context = Dispatchers.Default + CoroutineName("MyCoroutine")
    launch(context) {
        println("Running in ${Thread.currentThread().name} with name ${coroutineContext[CoroutineName]?.name}")
    }.join()
}
</syntaxhighlight>
'''输出：'''
<pre>
Running in DefaultDispatcher-worker-1 with name MyCoroutine
</pre>
在这个示例中，我们组合了 <code>Dispatchers.Default</code> 和 <code>CoroutineName("MyCoroutine")</code>，协程会在默认调度器上运行，并带有名称 "MyCoroutine"。

== 调度器（Dispatcher） ==
调度器是协程上下文中最重要的元素之一，它决定协程在哪个线程或线程池上执行。Kotlin提供了几种预定义的调度器：
* <code>Dispatchers.Default</code>：适用于CPU密集型任务。
* <code>Dispatchers.IO</code>：适用于I/O密集型任务。
* <code>Dispatchers.Main</code>：适用于UI线程（通常在Android或JavaFX中使用）。
* <code>Dispatchers.Unconfined</code>：不限制协程的执行线程。

示例：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        println("IO dispatcher: ${Thread.currentThread().name}")
    }
    launch(Dispatchers.Default) {
        println("Default dispatcher: ${Thread.currentThread().name}")
    }
}.join()
</syntaxhighlight>
'''输出：'''
<pre>
IO dispatcher: DefaultDispatcher-worker-2
Default dispatcher: DefaultDispatcher-worker-1
</pre>

== Job 和生命周期 ==
<code>Job</code> 是协程上下文的另一个关键元素，它表示协程的生命周期状态（如活跃、完成或取消）。可以通过 <code>Job</code> 控制协程的执行：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        repeat(5) { i ->
            delay(100)
            println("Job running $i")
        }
    }
    delay(250)
    job.cancel() // 取消协程
    println("Job cancelled")
}
</syntaxhighlight>
'''输出：'''
<pre>
Job running 0
Job running 1
Job cancelled
</pre>

== 协程名称和调试 ==
为协程命名可以方便调试和日志记录：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(CoroutineName("WorkerCoroutine")) {
        println("This is ${coroutineContext[CoroutineName]?.name}")
    }.join()
}
</syntaxhighlight>
'''输出：'''
<pre>
This is WorkerCoroutine
</pre>

== 异常处理 ==
<code>CoroutineExceptionHandler</code> 用于处理协程内部的未捕获异常：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Caught exception: $exception")
    }
    val job = GlobalScope.launch(handler) {
        throw RuntimeException("Test Exception")
    }
    job.join()
}
</syntaxhighlight>
'''输出：'''
<pre>
Caught exception: java.lang.RuntimeException: Test Exception
</pre>

== 上下文继承与组合 ==
协程上下文遵循父子继承关系，子协程默认继承父协程的上下文，但可以覆盖特定元素：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*

fun main() = runBlocking {
    val parentContext = Dispatchers.Default + CoroutineName("Parent")
    launch(parentContext) {
        println("Parent context: ${coroutineContext[CoroutineName]?.name}")
        launch(CoroutineName("Child")) {
            println("Child context: ${coroutineContext[CoroutineName]?.name}")
        }.join()
    }.join()
}
</syntaxhighlight>
'''输出：'''
<pre>
Parent context: Parent
Child context: Child
</pre>

== 实际应用案例 ==
假设我们开发一个网络请求应用，需要处理异步任务并记录日志：
<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*
import kotlinx.coroutines.Dispatchers.IO

fun fetchData(url: String) = CoroutineScope(IO + CoroutineName("FetchData")).launch {
    println("Fetching data from $url on ${Thread.currentThread().name}")
    // 模拟网络请求
    delay(1000)
    println("Data fetched")
}

fun main() = runBlocking {
    fetchData("https://api.example.com/data")
    delay(1500)
}
</syntaxhighlight>
'''输出：'''
<pre>
Fetching data from https://api.example.com/data on DefaultDispatcher-worker-1
Data fetched
</pre>

== 总结 ==
Kotlin协程上下文是协程运行时的核心配置，通过组合不同的元素（如调度器、Job、名称和异常处理器），可以灵活控制协程的行为。理解上下文的概念对于编写高效、可维护的异步代码至关重要。

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin协程]]