Android Kotlin 协程

Made In SQL

861人浏览 · 2025-07-28 13:40:29

Made In SQL · 2025-07-28 13:40:29 发布

Android Kotlin 协程是一种基于Kotlin语言的轻量级线程管理框架，由JetBrains公司于2017年开发并集成在Kotlin 1.3版本的标准库中。它通过挂起函数(suspend function)和结构化并发(structured concurrency)的概念，为Android开发提供了简单高效的异步编程解决方案。

在Android开发中，协程主要解决了以下几个痛点：

替代传统回调地狱(callback hell)，使异步代码可以采用类似同步的方式编写
相比RxJava等响应式编程框架，协程的学习曲线更平缓，代码更直观
内置的取消机制和异常处理使资源管理更加安全可靠
轻量级的线程切换(通常每个协程只需几十KB内存)大大降低了并发编程的资源消耗

协程的核心组件包括：

CoroutineScope：定义协程的生命周期范围
Dispatchers：提供Main、IO、Default等线程调度器
Job：表示一个协程任务
Deferred：带有返回值的Job

典型应用场景包括：

网络请求：使用withContext(Dispatchers.IO)切换IO线程执行网络操作
数据库操作：配合Room等ORM框架实现异步查询
UI更新：通过Dispatchers.Main在主线程安全更新界面
多任务并行：使用async/await实现并发执行多个任务

例如一个简单的网络请求实现：

viewModelScope.launch {
    try {
        val data = withContext(Dispatchers.IO) {
            repository.fetchData() // 挂起函数
        }
        updateUI(data) // 自动切换回主线程
    } catch (e: Exception) {
        showError(e)
    }
}

JetBrains官方数据显示，使用协程可以将异步代码量减少50%以上，同时显著降低内存泄露的风险。目前协程已成为Android官方推荐的异步编程方案，并与Jetpack组件如ViewModel、LiveData等深度集成。

核心特点：

轻量级线程：协程运行在线程之上，但比线程更轻量，可以创建数千个协程而不会导致性能问题
结构化并发：通过作用域(CoroutineScope)管理协程生命周期，避免内存泄漏
挂起机制：使用suspend关键字声明挂起函数，可以在不阻塞线程的情况下暂停和恢复执行
简化异步代码：用同步的方式编写异步代码，消除了回调地狱

主要组件：

CoroutineScope：协程作用域，管理协程生命周期
- GlobalScope：全局作用域
- ViewModelScope：与ViewModel生命周期绑定
- LifecycleScope：与Activity/Fragment生命周期绑定
CoroutineContext：协程上下文，包含：
- Dispatcher：决定协程在哪个线程运行
  - Dispatchers.Main：主线程
  - Dispatchers.IO：IO密集型操作
  - Dispatchers.Default：CPU密集型计算
- Job：协程的句柄，用于取消协程
- CoroutineExceptionHandler：异常处理
构建器：
- launch：启动不需要返回结果的协程
- async：启动需要返回结果的协程(返回Deferred<T>)
- runBlocking：阻塞当前线程直到协程执行完毕(主要用于测试)

典型使用场景：

网络请求：

viewModelScope.launch {
    try {
        val result = withContext(Dispatchers.IO) {
            apiService.fetchData()
        }
        // 更新UI
    } catch (e: Exception) {
        // 处理异常
    }
}

数据库操作：

lifecycleScope.launch {
    val users = withContext(Dispatchers.IO) {
        database.userDao().getAll()
    }
    // 使用查询结果
}

并行任务：

val deferred1 = async { fetchData1() }
val deferred2 = async { fetchData2() }
val results = awaitAll(deferred1, deferred2)

最佳实践：

避免使用GlobalScope：GlobalScope的生命周期与应用进程相同，可能导致内存泄漏。推荐使用：
- ViewModelScope：与ViewModel生命周期绑定
- LifecycleScope：与Activity/Fragment生命周期绑定示例：
```
class MyViewModel : ViewModel() {
    fun fetchData() {
        viewModelScope.launch {
            // 网络请求代码
        }
    }
}
```

职责分离：

ViewModel中处理业务逻辑：如网络请求、数据库操作
Activity/Fragment中只观察LiveData更新UI 示例：

// ViewModel
val userData = MutableLiveData<User>()
fun loadUser() {
    viewModelScope.launch {
        userData.value = repository.getUser()
    }
}

// Activity
viewModel.userData.observe(this) { user ->
    updateUI(user)
}

异常处理：

使用supervisorScope处理子协程异常（不会取消父协程）

对于可能被取消的协程：

coroutineScope.launch {
    try {
        // 耗时操作
    } finally {
        if(isActive) {
            // 资源清理
        }
    }
}

异常处理详细方案：

基本捕获：

viewModelScope.launch {
    try {
        fetchData()
    } catch (e: Exception) {
        showError(e)
    }
}

全局异常处理：

val handler = CoroutineExceptionHandler { _, exception ->
    Log.e("CoroutineError", "Caught $exception")
}

viewModelScope.launch(handler) {
    // 可能抛出异常的代码
}

async/await异常处理：

viewModelScope.launch {
    val deferred = async { fetchData() }
    try {
        val result = deferred.await()
    } catch (e: Exception) {
        // 处理异常
    }
}

应用场景：