「一文搞懂 Kotlin 协程」从入门到实战完全指南前言协程是 Kotlin 最强大的特性之一它让你用同步的方式写异步代码彻底告别 Callback 地狱。┌─────────────────────────────────────────────────────────────┐ │ Kotlin 协程核心概念 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ suspend 挂起函数 — 可暂停执行而不阻塞线程 │ │ CoroutineScope 协程作用域 — 管理协程的生命周期 │ │ Dispatcher 调度器 — 决定协程在哪个线程执行 │ │ Job 任务 — 协程的句柄可取消 │ │ │ │ ┌─────────────────────────────────────────────────────┐ │ │ │ 协程 vs 线程 │ │ │ │ 线程阻塞式重量级创建/切换成本高 │ │ │ │ 协程挂起式轻量级数千个协程可共存在单线程中 │ │ │ └─────────────────────────────────────────────────────┘ │ │ │ └─────────────────────────────────────────────────────────────┘一、基本用法1.1 协程依赖// build.gradle.ktsdependencies{implementation(org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3)implementation(org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3)// Lifecycle 协程支持implementation(androidx.lifecycle:lifecycle-runtime-ktx:2.6.2)implementation(androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.2)}1.2 suspend 关键字 — 定义挂起函数// 普通函数不能调用 suspend 函数funnormalFunction(){// fetchUser() // ❌ 编译错误}// suspend 函数可以在协程中被暂停suspendfunfetchUser(username:String):GitHubUser{// 可以调用其他 suspend 函数// 可以在任意位置挂起awaitreturnwithContext(Dispatchers.IO){apiService.getUser(username)}}1.3 launch — 启动协程不返回结果// launch 返回 Job可用于取消valjoblifecycleScope.launch{// 这是协程体valuserfetchUser(google)textView.textuser.name// 直接更新 UI}// 取消协程job.cancel()1.4 async/await — 并行执行并获取结果lifecycleScope.launch{// ❌ 串行执行浪费时间valuserfetchUser(google)valreposfetchRepos(google)// ✅ 并行执行快一倍valuserDeferredasync{fetchUser(google)}valreposDeferredasync{fetchRepos(google)}valuseruserDeferred.await()valreposreposDeferred.await()}// async 返回 DeferredT相当于带结果的 Job// await() 等待结果并返回1.5 withContext — 线程切换suspendfunfetchUser(username:String):GitHubUser{// 切换到 IO 线程执行网络请求returnwithContext(Dispatchers.IO){// 这里在 IO 线程apiService.getUser(username)}// 自动切回调用线程通常是主线程}// Dispatchers 选择// Dispatchers.IO - 网络请求、读写文件// Dispatchers.Default - CPU 密集型计算排序、JSON 解析// Dispatchers.Main - UI 更新Android 主线程二、协程作用域2.1 作用域全景图┌─────────────────────────────────────────────────────────────┐ │ 协程作用域层级 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ GlobalScope 应用级别不推荐长期运行 │ │ │ │ │ CoroutineScope 自定义作用域手动管理 │ │ │ │ │ viewModelScope ViewModel 级别ViewModel 清除时结束│ │ │ │ │ lifecycleScope Activity/Fragment 级别销毁时结束 │ │ │ └─────────────────────────────────────────────────────────────┘2.2 lifecycleScope — Activity/Fragment 专用classMainActivity:AppCompatActivity(){funloadData(){// ✅ 推荐自动随 Activity 销毁而取消lifecycleScope.launch{try{valdatawithContext(Dispatchers.IO){api.getData()}updateUI(data)}catch(e:Exception){showError(e.message)}}}// Fragment 中同样适用}classMyFragment:Fragment(){funloadData(){lifecycleScope.launch{// 同样自动管理生命周期}}}2.3 viewModelScope — ViewModel 专用classMyViewModel:ViewModel(){privateval_userMutableLiveDataGitHubUser()valuser:LiveDataGitHubUser_userprivateval_reposMutableLiveDataListGitHubRepo()valrepos:LiveDataListGitHubRepo_reposfunfetchUser(username:String){// ✅ ViewModel 清除时自动取消不会内存泄漏viewModelScope.launch{try{valuserResultwithContext(Dispatchers.IO){repository.getUser(username)}_user.valueuserResult}catch(e:Exception){// 处理错误}}}// ✅ 并行加载funfetchUserAndRepos(username:String){viewModelScope.launch{valuserDeferredasync{repository.getUser(username)}valreposDeferredasync{repository.getRepos(username)}valuseruserDeferred.await()valreposreposDeferred.await()_user.valueuser _repos.valuerepos}}}2.4 GlobalScope — 不推荐但要了解// ❌ 不推荐生命周期与应用相同可能导致// 1. Activity 已销毁但协程仍在执行 → 更新 UI 崩溃// 2. 内存泄漏GlobalScope.launch{while(true){// 永远运行的协程delay(1000)// updateUI() // ❌ 如果 Activity 已销毁崩溃}}// ✅ 如果确实需要应用级别的作用域自己管理classApp:Application(){privatevalapplicationScopeCoroutineScope(SupervisorJob()Dispatchers.Main)fundoWork(){applicationScope.launch{// 手动管理生命周期}}overridefunonTerminate(){applicationScope.cancel()super.onTerminate()}}2.5 runBlocking — 仅用于测试// ✅ 正确用法测试环境RunWith(AndroidJUnit4::class)classExampleTest{TestfuntestBlocking()runBlocking{valresultasync{fetchData()}.await()assertEquals(expected,result)}}// ❌ 绝对不要在生产代码中使用// 会阻塞当前线程如果用在主线程会导致 ANRfunbadExample(){runBlocking{// ❌ 这会阻塞主线程fetchUser()}}2.6 自定义 CoroutineScope// 场景需要手动控制协程生命周期classMyManager{privatevalscopeCoroutineScope(SupervisorJob()Dispatchers.Main)fundoWork(){scope.launch{// 工作}}fundestroy(){scope.cancel()// 取消所有协程}}// 使用 SupervisorJob子协程失败不影响兄弟协程privatevalscopeCoroutineScope(SupervisorJob()Dispatchers.Main)三、利用协程简化回调3.1 回调地狱 — 旧时代的噩梦// ❌ 旧方式Callback 地狱funfetchUserCallback(username:String,callback:(User?,Throwable?)-Unit){thread{try{valuserapi.getUser(username)handler.post{callback(user,null)}}catch(e:Exception){handler.post{callback(null,e)}}}}// 调用时...fetchUserCallback(google){user,error-if(error!null){showError(error.message)returnfetchUserCallback}fetchReposCallback(user.id){repos,error2-if(error2!null){showError(error2.message)returnfetchReposCallback}// 又一层嵌套...崩溃边缘}}3.2 suspendCoroutine — 包装任意回调// ✅ 将 Callback API 转换为 suspend 函数suspendfunfetchUserSuspend(username:String):ResultGitHubUsersuspendCoroutine{continuation-oldApi.fetchUser(username,object:CallbackGitHubUser{overridefunonSuccess(user:GitHubUser){// 返回成功结果continuation.resume(Result.success(user))}overridefunonError(error:Throwable){// 返回失败结果continuation.resume(Result.failure(error))}})}// 调用时...就像写同步代码一样lifecycleScope.launch{valresultfetchUserSuspend(google)result.onSuccess{user-updateUI(user)}.onFailure{error-showError(error.message)}}3.3 callbackFlow — 包装流式回调位置更新、消息等// ✅ 将位置更新包装为 FlowfunlocationUpdates():FlowLocationcallbackFlow{valcallbackobject:LocationCallback(){overridefunonLocationResult(result:LocationResult){result.lastLocation?.let{location-trySend(location)// 发送位置到 Flow}}}fusedLocationClient.requestLocationUpdates(LocationRequest.create(),callback,Looper.getMainLooper())// 清理取消订阅时移除监听器awaitClose{fusedLocationClient.removeLocationUpdates(callback)}}// 使用像操作集合一样操作位置更新lifecycleScope.launch{locationUpdates().filter{it.accuracy100f}// 过滤高精度.map{${it.latitude},${it.longitude}}// 转换.collect{coordinates-// 每次位置更新都会执行textView.textcoordinates}}3.4 suspendFlow / flow 的高级用法// Flow 切换线程fungetUsersFlow():FlowListUserflow{valuserswithContext(Dispatchers.IO){api.getUsers()}emit(users)// 发送数据}.flowOn(Dispatchers.IO)// 指定流操作的线程// 使用lifecycleScope.launch{getUsersFlow().collect{users-adapter.submitList(users)// 主线程更新 UI}}// channelFlow — 可以在流中调用挂起函数funevents():FlowEventchannelFlow{valcallbackobject:EventCallback{overridefunonEvent(event:Event){trySend(event)// 可以调用挂起函数}}eventBus.register(callback)awaitClose{eventBus.unregister(callback)}}3.5 完整的 Retrofit 协程示例// API 接口interfaceGitHubApiService{GET(users/{username})suspendfungetUser(Path(username)username:String):ResponseGitHubUser}// RepositoryclassUserRepository{privatevalapiServiceRetrofitClient.apiService// ✅ Result 封装统一错误处理suspendfungetUser(username:String):ResultGitHubUser{returntry{valresponseapiService.getUser(username)if(response.isSuccessfulresponse.body()!null){Result.success(response.body()!!)}else{Result.failure(Exception(Error:${response.code()}))}}catch(e:Exception){Result.failure(e)}}}// ViewModelclassUserViewModel:ViewModel(){privatevalrepositoryUserRepository()privateval_userMutableLiveDataGitHubUser()valuser:LiveDataGitHubUser_userprivateval_isLoadingMutableLiveDataBoolean()valisLoading:LiveDataBoolean_isLoadingfunfetchUser(username:String){viewModelScope.launch{_isLoading.valuetruerepository.getUser(username).onSuccess{_user.valueit}.onFailure{/* 处理错误 */}_isLoading.valuefalse}}}// ActivityclassUserActivity:AppCompatActivity(){privatevalviewModel:UserViewModelbyviewModels()overridefunonCreate(savedInstanceState:Bundle?){super.onCreate(savedInstanceState)viewModel.user.observe(this){user-textView.textuser.name}viewModel.isLoading.observe(this){isLoading-progressBar.visibilityif(isLoading)View.VISIBLEelseView.GONE}button.setOnClickListener{viewModel.fetchUser(google)}}}四、Dispatchers 选择指南┌─────────────────────────────────────────────────────────────┐ │ Dispatchers 选择 │ ├─────────────────────────────────────────────────────────────┤ │ │ │ Dispatchers.Main Android 主线程 │ │ ├── updateUI() │ │ ├── liveData.postValue() │ │ └── binding.textView.text hi │ │ │ │ Dispatchers.IO 网络请求、读写文件、数据库 │ │ ├── api.getUser() │ │ ├── FileInputStream.read() │ │ └── roomDatabase.query() │ │ │ │ Dispatchers.Default CPU 密集型计算 │ │ ├── JSON.parse() │ │ ├── List.sort() │ │ └── BitmapFactory.decodeStream() │ │ │ └─────────────────────────────────────────────────────────────┘lifecycleScope.launch(Dispatchers.Main){// 默认就是 Main可省略valdatawithContext(Dispatchers.IO){api.getData()// 网络在 IO}textView.textdata// UI 在 Main}五、取消与异常处理5.1 协程取消valjoblifecycleScope.launch{repeat(1000){i-println(Job:$i)delay(100)}}// 取消协程job.cancel()// 取消并等待完成job.cancelAndJoin()// 协作取消检查 isActivelifecycleScope.launch{for(iin0..1000){if(!isActive)break// 检查是否已取消println(Job:$i)delay(100)}}5.2 异常处理lifecycleScope.launch{try{// 使用 withContext 时异常会被重新抛出valdatawithContext(Dispatchers.IO){api.getData()}updateUI(data)}catch(e:CancellationException){// 协程被取消正常的throwe}catch(e:Exception){// 网络错误等showError(e.message)}}// SupervisorJob子协程失败不影响兄弟协程valsupervisorSupervisorJob()lifecycleScope.launch(supervisor){// 这个失败不会影响下面的协程launch{throwException(Oops!)}launch{/* 继续执行 */}}六、协程 LiveData 最佳实践classUserViewModel:ViewModel(){privatevalrepositoryUserRepository()// ✅ liveData 协程 builder自动在主线程观察valuser:LiveDataResultGitHubUserliveData{emit(Result.loading())try{valuserwithContext(Dispatchers.IO){repository.getUser(google)}emit(Result.success(user))}catch(e:Exception){emit(Result.failure(e))}}// ✅ 使用viewModel.user.observe(this){result-when(result){isResult.Loading-showLoading()isResult.Success-showUser(result.data)isResult.Failure-showError(result.exception.message)}}}// Result 密封类sealedclassResultoutT{dataclassSuccessT(valdata:T):ResultT()dataclassFailure(valexception:Throwable):ResultNothing()objectLoading:ResultNothing()}总结┌────────────────────────────────────────────────────────────┐ │ Kotlin 协程全景图 │ ├────────────────────────────────────────────────────────────┤ │ │ │ 基础三要素 │ │ ├── suspend 定义挂起函数 │ │ ├── launch 启动协程不返回结果 │ │ └── async/await 启动协程返回结果 并行 │ │ │ │ 五大作用域 │ │ ├── lifecycleScope Activity/Fragment推荐 │ │ ├── viewModelScope ViewModel推荐 │ │ ├── GlobalScope 不推荐长期运行 │ │ ├── CoroutineScope 自定义作用域 │ │ └── runBlocking 仅测试 │ │ │ │ 简化回调三剑客 │ │ ├── withContext 线程切换 │ │ ├── suspendCoroutine 包装 Callback → suspend │ │ └── callbackFlow 包装流式回调 → Flow │ │ │ │ Dispatchers 三兄弟 │ │ ├── Main UI 线程 │ │ ├── IO 网络/文件专为 IO 优化 │ │ └── Default CPU 计算 │ │ │ │ 黄金法则 │ │ ├── 用 lifecycleScope/viewModelScope 管理生命周期 │ │ ├── 网络/文件操作必须用 withContext(Dispatchers.IO) │ │ ├── 协程会自动随组件销毁而取消 │ │ └── Result 封装让错误处理更优雅 │ │ │ └────────────────────────────────────────────────────────────┘