编辑“︁Kotlin协程创建”︁（章节）

= Kotlin协程创建 =

Kotlin协程是一种轻量级的并发编程框架，它允许开发者以顺序的方式编写异步代码，同时避免传统线程模型中的复杂性。协程的创建是使用Kotlin协程的第一步，理解如何正确创建协程对于编写高效、可维护的异步代码至关重要。

== 协程的基本概念 ==

协程是一种可以在不阻塞线程的情况下挂起和恢复执行的函数。与线程不同，协程的开销极小，可以在单个线程上运行成千上万个协程。Kotlin协程通过挂起函数（suspend functions）和协程构建器（coroutine builders）来实现这一功能。

== 协程的创建方式 ==

在Kotlin中，协程的创建主要通过协程构建器（coroutine builders）实现。以下是几种常见的协程构建器：

=== 1. `launch` ===

`launch` 是最常用的协程构建器之一，它启动一个不会返回结果的协程（即“发射并忘记”模式）。它通常用于执行不需要返回值的异步任务。

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

fun main() {
    println("Main thread starts")

    // 使用 GlobalScope.launch 创建一个协程
    GlobalScope.launch {
        delay(1000) // 非阻塞延迟
        println("Coroutine executed after delay")
    }

    println("Main thread continues")
    Thread.sleep(2000) // 阻塞主线程以等待协程完成
    println("Main thread ends")
}
</syntaxhighlight>

'''输出：'''
<pre>
Main thread starts
Main thread continues
Coroutine executed after delay
Main thread ends
</pre>

'''解释：'''
- `GlobalScope.launch` 在全局作用域中启动一个协程。
- `delay(1000)` 是一个挂起函数，它不会阻塞线程，而是挂起协程。
- 主线程继续执行，而协程在后台运行。

=== 2. `async` ===

`async` 是另一个协程构建器，它返回一个 `Deferred` 对象，可以通过 `await()` 获取结果。它通常用于需要返回值的异步任务。

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

fun main() = runBlocking {
    println("Main coroutine starts")

    val deferredResult: Deferred<Int> = async {
        delay(1000)
        42 // 返回结果
    }

    println("Main coroutine continues")
    val result = deferredResult.await() // 等待结果
    println("Result is $result")

    println("Main coroutine ends")
}
</syntaxhighlight>

'''输出：'''
<pre>
Main coroutine starts
Main coroutine continues
Result is 42
Main coroutine ends
</pre>

'''解释：'''
- `async` 启动一个协程并返回 `Deferred<Int>`。
- `await()` 是一个挂起函数，它会挂起当前协程直到结果可用。
- 协程的执行顺序是线性的，但不会阻塞线程。

=== 3. `runBlocking` ===

`runBlocking` 是一个特殊的协程构建器，它会阻塞当前线程直到协程完成。它通常用于测试或主函数中。

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

fun main() = runBlocking {
    println("Main coroutine starts")

    launch {
        delay(1000)
        println("Child coroutine executed")
    }

    println("Main coroutine ends")
}
</syntaxhighlight>

'''输出：'''
<pre>
Main coroutine starts
Main coroutine ends
Child coroutine executed
</pre>

'''解释：'''
- `runBlocking` 创建一个协程并阻塞当前线程。
- `launch` 在 `runBlocking` 的作用域中启动子协程。
- 主协程会等待所有子协程完成。

== 协程的作用域 ==

协程的作用域（CoroutineScope）决定了协程的生命周期。以下是几种常见的作用域：

=== 1. `GlobalScope` ===
- 协程的生命周期与应用程序相同。
- 通常不推荐使用，因为可能导致内存泄漏。

=== 2. `CoroutineScope` ===
- 自定义作用域，可以通过 `coroutineScope` 或 `supervisorScope` 创建。
- 推荐用于结构化并发。

=== 3. `viewModelScope`（Android） ===
- 在Android中，`ViewModel` 提供 `viewModelScope`，协程会在 `ViewModel` 销毁时自动取消。

== 实际应用案例 ==

以下是一个实际应用场景：从网络异步加载数据并更新UI。

<syntaxhighlight lang="kotlin">
import kotlinx.coroutines.*
import kotlinx.coroutines.Dispatchers

// 模拟网络请求
suspend fun fetchData(): String {
    delay(2000) // 模拟网络延迟
    return "Data loaded"
}

fun main() = runBlocking {
    println("Start loading data")

    val result = async(Dispatchers.IO) { // 在IO线程池中执行
        fetchData()
    }

    // 模拟UI更新
    launch(Dispatchers.Main) {
        val data = result.await()
        println("UI updated with: $data")
    }

    println("Main thread continues")
}
</syntaxhighlight>

'''输出：'''
<pre>
Start loading data
Main thread continues
UI updated with: Data loaded
</pre>

'''解释：'''
- `Dispatchers.IO` 用于网络请求等IO操作。
- `Dispatchers.Main` 用于更新UI（在Android中）。
- `async` 和 `launch` 结合使用以实现异步加载和UI更新。

== 协程的生命周期 ==

协程的生命周期可以通过 `Job` 对象控制。以下是关键方法：
- `start()`：启动协程。
- `cancel()`：取消协程。
- `join()`：等待协程完成。

<mermaid>
stateDiagram
    [*] --> New
    New --> Active: start()
    Active --> Completing: 完成
    Completing --> Completed: 完成所有子协程
    Active --> Cancelling: cancel()
    Cancelling --> Cancelled: 完成取消
    Completed --> [*]
    Cancelled --> [*]
</mermaid>

== 总结 ==

Kotlin协程的创建是通过协程构建器（如 `launch`、`async` 和 `runBlocking`）实现的。理解这些构建器的作用以及协程的作用域和生命周期对于编写高效的异步代码至关重要。通过实际案例，我们可以看到协程如何简化异步编程并提高代码的可读性。

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