当前位置：首页 > article >正文

Kotlin 协程与异步编程

article 2025/1/7 3:56:55

Kotlin 协程是异步编程的利器，它能让代码以同步方式编写，同时具备非阻塞的异步特性。这极大地简化了多线程和异步任务的实现，避免了回调地狱，并提供更强的可读性和简洁性。

一、协程的基本概念与使用场景

1. 什么是协程？

协程是一种轻量级的线程，能够以非阻塞方式执行异步代码。与传统线程相比，协程更具优势：

轻量级：协程比线程更轻量，可以同时运行成千上万个协程而不消耗大量内存。
挂起与恢复：协程可以挂起，释放线程资源，稍后在挂起的位置继续执行。
更易管理：协程通过作用域和结构化并发管理生命周期，避免内存泄漏。

2. 使用场景

网络请求：异步调用多个 API 并在完成后组合结果。
并行任务：同时执行多个任务，汇总结果。
耗时计算：在后台线程执行计算任务，避免阻塞主线程。

二、启动协程：`launch` 和 `async`

Kotlin 提供了多种方式来启动协程，主要使用 launch 和 async。

1. `launch` 启动协程

特点：返回 Job 对象，不返回结果。
适用场景：希望启动一个后台任务但不关心其结果。

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000L)
        println("任务完成")
    }
    println("主线程继续执行")
}

输出结果：

主线程继续执行
任务完成

2. `async` 启动协程

特点：返回 Deferred，可以通过 await 获取返回结果。
适用场景：需要并发执行并收集返回结果。

import kotlinx.coroutines.*

fun main() = runBlocking {
    val result = async {
        delay(1000L)
        "返回结果"
    }
    println("等待结果...")
    println(result.await())
}

三、`suspend` 关键字与挂起函数

1. `suspend` 关键字

suspend 关键字用于定义挂起函数，可以在协程中调用。挂起函数可以在执行时挂起而不阻塞线程。

suspend fun fetchData(): String {
    delay(1000L)  // 模拟耗时任务
    return "数据加载完成"
}

fun main() = runBlocking {
    println("开始加载数据")
    val result = fetchData()
    println(result)
}

特点：

suspend 函数必须在协程或其他挂起函数中调用。
delay 函数不会阻塞线程，而是挂起协程，使线程可用于其他任务。

四、协程作用域与异常处理

1. 协程作用域

Kotlin 提供了不同的协程作用域，管理协程生命周期：

runBlocking：阻塞当前线程，直到协程执行完成（通常用于主函数）。
CoroutineScope：协程的生命周期受限于 CoroutineScope，常用于 UI 和应用生命周期管理。
GlobalScope：生命周期与应用程序一致，容易引起内存泄漏，谨慎使用。

fun main() = runBlocking {
    val job = launch {
        delay(2000L)
        println("任务完成")
    }
    job.join()
}

2. 协程异常处理

协程异常处理可以通过 try-catch，或 CoroutineExceptionHandler 捕获异常。

fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, exception ->
        println("Caught exception: $exception")
    }

    val job = launch(handler) {
        throw IllegalArgumentException("异常发生")
    }
    job.join()
}

五、并发与异步流（Flow）

1. 什么是 Flow？

Flow 是 Kotlin 中的异步数据流，适用于大量数据或流式数据处理。它类似于 RxJava 中的 Observable，可以逐步返回数据。

import kotlinx.coroutines.flow.*

fun fetchDataFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(500L)
        emit(i)  // 发射数据
    }
}

fun main() = runBlocking {
    fetchDataFlow().collect { value ->
        println("接收到：$value")
    }
}

六、实战：创建一个简单的天气查询应用

需求描述：

使用协程异步请求两个 API：当前天气和未来预报。
合并结果后展示给用户。

代码示例：

import kotlinx.coroutines.*
import kotlin.random.Random

suspend fun fetchCurrentWeather(): String {
    delay(1000L)  // 模拟网络请求
    return "当前天气：晴天"
}

suspend fun fetchWeatherForecast(): String {
    delay(1500L)  // 模拟网络请求
    return "未来预报：多云"
}

fun main() = runBlocking {
    println("开始获取天气信息...")

    val currentWeather = async { fetchCurrentWeather() }
    val forecast = async { fetchWeatherForecast() }

    println("天气信息加载中...")
    println(currentWeather.await())
    println(forecast.await())
}

七、协程中的最佳实践

使用结构化并发：使用 CoroutineScope 保证协程在作用域内完整执行，防止内存泄漏。
避免使用 GlobalScope：GlobalScope 启动的协程与应用生命周期一致，不易控制。
合理使用 async 和 launch：
- 使用 launch 启动不关心返回值的任务。
- 使用 async 启动并发任务，返回 Deferred 并使用 await 获取结果。
异常处理：始终在协程中捕获异常，避免协程泄漏或程序崩溃。