Kotlin协程实战：比Java线程更优雅的并发编程

前言

Kotlin 协程（Coroutines）是 Android 和服务端开发者的必备技能。相比 Java 线程，协程更轻量、更易读、更安全。本文带你从零掌握 Kotlin 协程的核心用法。
一、协程 vs 线程

• 线程：操作系统调度，创建成本高（约1MB栈内存）
  
• 协程：用户态调度，创建成本极低（约几KB），可创建数十万个
  

1. // Java 线程：10000个线程会OOM
2. for (int i = 0; i < 10000; i++) {
3.     new Thread(() -> doWork()).start();
4. }
6. // Kotlin 协程：100000个协程轻松运行
7. repeat(100_000) {
8.     GlobalScope.launch { doWork() }
9. }

复制代码

二、第一个协程

1. import kotlinx.coroutines.*
3. fun main() = runBlocking {
4.     // 启动协程
5.     launch {
6.         delay(1000)  // 非阻塞延迟
7.         println("World!")
8.     }
9.     println("Hello,")
10. }
11. // 输出：
12. // Hello,
13. // (1秒后) World!

复制代码

三、协程作用域（CoroutineScope）

1. // 1. GlobalScope：全局作用域，生命周期跟随应用
2. GlobalScope.launch {
3.     println("Global scope")
4. }
6. // 2. runBlocking：阻塞当前线程直到协程完成
7. runBlocking {
8.     launch { println("runBlocking") }
9. }
11. // 3. coroutineScope：挂起当前协程，等待子协程完成
12. suspend fun loadData() = coroutineScope {
13.     launch { fetchUser() }
14.     launch { fetchOrders() }
15. }
17. // 4. ViewModelScope（Android）：跟随 ViewModel 生命周期
18. viewModelScope.launch {
19.     val data = repository.fetchData()
20.     updateUI(data)
21. }

复制代码

四、挂起函数（suspend）

1. // 挂起函数：可在协程中暂停执行，不阻塞线程
2. suspend fun fetchUser(): User {
3.     return withContext(Dispatchers.IO) {
4.         // 切换到 IO 线程执行网络请求
5.         api.getUser()
6.     }
7. }
9. // 调用挂起函数
10. fun loadData() = viewModelScope.launch {
11.     showLoading()
12.     val user = fetchUser()  // 挂起，等待结果
13.     updateUI(user)          // 恢复执行
14.     hideLoading()
15. }

复制代码

五、协程调度器（Dispatcher）

1. // 1. Dispatchers.Main：主线程（UI 操作）
2. withContext(Dispatchers.Main) {
3.     textView.text = "Updated"
4. }
6. // 2. Dispatchers.IO：IO 密集型（网络、数据库）
7. withContext(Dispatchers.IO) {
8.     val data = api.fetchData()
9.     database.save(data)
10. }
12. // 3. Dispatchers.Default：CPU 密集型（排序、计算）
13. withContext(Dispatchers.Default) {
14.     val sorted = list.sortedBy { it.id }
15. }
17. // 4. 自定义线程池
18. val customDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()
19. withContext(customDispatcher) {
20.     heavyComputation()
21. }

复制代码

六、异常处理

1. // CoroutineExceptionHandler：全局异常捕获
2. val handler = CoroutineExceptionHandler { _, e ->
3.     println("Caught: $e")
4. }
6. val job = GlobalScope.launch(handler) {
7.     throw RuntimeException("Error!")
8. }
10. // try-catch：局部异常处理
11. try {
12.     val result = async {
13.         riskyOperation()
14.     }.await()
15. } catch (e: Exception) {
16.     handleError(e)
17. }

复制代码

七、实战：并发请求

1. data class User(val id: Int, val name: String)
2. data class Order(val id: Int, val userId: Int)
4. suspend fun loadUserData(userId: Int): Pair<User, List<Order>> {
5.     return coroutineScope {
6.         // 并发执行两个请求
7.         val userDeferred = async { fetchUser(userId) }
8.         val ordersDeferred = async { fetchOrders(userId) }
9.         
10.         // 等待结果
11.         Pair(userDeferred.await(), ordersDeferred.await())
12.     }
13. }
15. // 对比 Java CompletableFuture
16. // Kotlin 协程写法更简洁，无需回调链

复制代码

总结

Kotlin 协程让并发编程变得优雅。核心要点：

• 轻量级：可创建数十万协程而不 OOM
  

结构化并发

：作用域自动管理协程生命周期

挂起函数

：用同步写法实现异步逻辑

调度器

：灵活切换线程，适配不同场景

觉得有帮助请点赞收藏！有问题欢迎评论区交流
来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！