1 前言
相较于 C# 中的协程（详见 → 【Unity3D】协同程序），Kotlin 中协程更灵活，难度更大。
协程是一种并发设计模式，用于简化异步编程，它允许以顺序化的方式表达异步操作，避免回调地狱等问题。使用协程，可以将异步操作的代码像同步代码一样写，而无需显式地管理线程。
在 Kotlin 中，协程由 kotlinx.coroutines 库提供支持。它使用 suspend 修饰符来标记挂起函数（即可暂停执行并稍后恢复执行的函数），这使得编写异步代码更加直观和简单。
协程和线程具有以下异同点。
1）并发模型
- 线程：线程是操作系统提供的执行单位，一个进程可以拥有多个线程，线程之间相对独立，数据共享需要通过特殊手段（如锁）保证安全。
- 协程：协程是一种用户态的轻量级线程，由开发者控制其运行与暂停，可以在同一线程上并发执行，通过挂起和恢复的方式，实现非阻塞的并发。
2）资源消耗
- 线程：每个线程都需要分配一定的内存和系统资源，线程切换时会有一定的开销。
- 协程：协程是用户级的，由协程调度器（Coroutine Dispatcher）调度，通常会复用较少的系统资源，因此更轻量级。
3）编程模型
- 线程：多线程编程通常以共享状态和锁为基础，编写并发代码较为复杂。
- 协程：协程提供了一种结构化并发编程的方式，通过挂起函数的调用实现代码的暂停和恢复，使得异步编程更易于理解和维护。
4）错误处理
- 线程：多线程编程中，错误处理相对困难，需要开发者手动处理异常和线程间的通信。
- 协程：协程提供了更加简单和一致的错误处理方式，通过结构化的异常处理机制，可以轻松处理协程中的异常。
5）性能
- 线程：创建和管理线程可能会带来较大的开销，尤其是在大量线程同时运行时，线程切换的开销也会比较高。
- 协程：协程由于是轻量级的用户级线程，资源消耗较少，因此在大规模并发场景下可能表现更优。
总的来说，协程相比于传统的线程模型，更加灵活、轻量级，并且提供了更加简单和结构化的并发编程方式，使得异步编程更加容易和优雅。
2 协程相关类图
3 协程源码
3.1 协程作用域源码（CoroutinueScope）
协程的作用域定义了协程的作用域范围，当该作用域被销毁时，其中的协程也会被取消。协程的作用阈主要有 CoroutineScope、MainScope、GlobalScope、lifecycleScope 、viewModelScope，主要区别如下。
- CoroutineScope：CoroutineScope 是通用的协程作用域，用于定义协程的作用域范围，当该作用域被销毁时，其中的协程也会被取消。
- MainScope：MainScope 是 Kotlin 中提供的特定于 Android 的协程作用域，用于在 Android 主线程上启动协程，通常在 Android 的 Activity 或 Fragment 中使用 MainScope，以确保在主线程上运行协程，并在相关生命周期结束时取消协程。
- GlobalScope：GlobalScope 是 Kotlin 中提供的一个全局协程作用域，它是一个顶层对象，用户可以在任何地方使用 GlobalScope 启动协程，但不推荐在 Android 中使用它，因为它的生命周期很长，并且不受管理，可能导致内存泄漏等问题。
- lifecycleScope：lifecycleScope 是 Android Jetpack 中的 Lifecycle 模块提供的一个扩展属性，它的生命周期与相关的组件（如 Activity 或 Fragment）的生命周期绑定，从而避免内存泄漏等问题。
- viewModelScope：viewModelScope 是 Android Jetpack 中 Lifecycle 模块提供的一个扩展属性，它的生命周期与 ViewModel 的生命周期绑定，从而避免内存泄漏等问题。
3.1.1 CoroutineScope
public fun CoroutineScope(context: CoroutineContext): CoroutineScope = ContextScope(if (context[Job] != null) context else context + Job()) 说明：CoroutineScope 是通用的协程作用域，用于定义协程的作用域范围，当该作用域被销毁时，其中的协程也会被取消。
3.1.2 MainScope
public fun MainScope(): CoroutineScope = ContextScope(SupervisorJob() + Dispatchers.Main) 说明：MainScope 是 Kotlin 中提供的特定于 Android 的协程作用域，用于在 Android 主线程上启动协程，通常在 Android 的 Activity 或 Fragment 中使用 MainScope，以确保在主线程上运行协程，并在相关生命周期结束时取消协程。
3.1.3 GlobalScope
public object GlobalScope : CoroutineScope 说明：GlobalScope 是 Kotlin 中提供的一个全局协程作用域，它是一个顶层对象，用户可以在任何地方使用 GlobalScope 启动协程，但不推荐在 Android 中使用它，因为它的生命周期很长，并且不受管理，可能导致内存泄漏等问题。GlobalScope 是一个单例，其作用域的生命周期跟随应用程序的生命周期，中间不能取消（cancel）。
3.1.4 lifecycleScope
public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope get() = lifecycle.coroutineScope // ----------------------------------------------------------- public val Lifecycle.coroutineScope: LifecycleCoroutineScope get() { while (true) { val existing = mInternalScopeRef.get() as LifecycleCoroutineScopeImpl? if (existing != null) { return existing } val newScope = LifecycleCoroutineScopeImpl(this, SupervisorJob() + Dispatchers.Main.immediate ) if (mInternalScopeRef.compareAndSet(null, newScope)) { newScope.register() return newScope } } } // ----------------------------------------------------------- internal class LifecycleCoroutineScopeImpl( override val lifecycle: Lifecycle, override val coroutineContext: CoroutineContext ) : LifecycleCoroutineScope(), LifecycleEventObserver // ----------------------------------------------------------- public abstract class LifecycleCoroutineScope internal constructor() : CoroutineScope 说明：lifecycleScope 是 Android Jetpack 中的 Lifecycle 模块提供的一个扩展属性，它的生命周期与相关的组件（如 Activity 或 Fragment）的生命周期绑定，从而避免内存泄漏等问题。
使用 lifecycleScope 时，需要在 build.gradle 中引入以下依赖。
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.1" 并导入包名。
import androidx.lifecycle.lifecycleScope AppCompatActivity、FragmentActivity 与 LifecycleOwner 存在以下继承关系。因此可以在 AppCompatActivity 和 FragmentActivity 中直接访问 lifecycleScope。
AppCompatActivity → FragmentActivity → ComponentActivity → LifecycleOwner 3.1.5 viewModelScope
public val ViewModel.viewModelScope: CoroutineScope get() { val scope: CoroutineScope? = this.getTag(JOB_KEY) if (scope != null) { return scope } return setTagIfAbsent(JOB_KEY, CloseableCoroutineScope(SupervisorJob() + Dispatchers.Main.immediate) ) } // -------------------------------------------------------------------------- internal class CloseableCoroutineScope(context: CoroutineContext) : Closeable, CoroutineScope { override val coroutineContext: CoroutineContext = context override fun close() { coroutineContext.cancel() } } 说明：viewModelScope 是 Android Jetpack 中 Lifecycle 模块提供的一个扩展属性，它的生命周期与 ViewModel 的生命周期绑定，从而避免内存泄漏等问题。
使用 viewModelScope 时，需要在 build.gradle 中引入以下依赖。
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1' 并导入包名。
import androidx.lifecycle.viewModelScope 3.2 协程调度器源码（Dispatchers）
public actual object Dispatchers { // 线程池, 适合执行CPU密集型任务(大量占用量CPU的任务) public actual val Default: CoroutineDispatcher = DefaultScheduler // Android中是UI线程, Swing中是invokerLater线程 public actual val Main: MainCoroutineDispatcher get() = MainDispatcherLoader.dispatcher // 在当前线程上执行 public actual val Unconfined: CoroutineDispatcher = kotlinx.coroutines.Unconfined // 线程池, 适合执行磁盘读写、网络IO、数据库操作等任务 public val IO: CoroutineDispatcher = DefaultIoScheduler // ... } 3.3 协程启动方式源码
协程的启动方式主要有 launch、async、runBlocking、withContext，它们的区别如下。
- launch：launch 用于启动一个新的协程，并返回一个 Job 对象，该对象代表了这个新协程；启动的协程在后台运行，不会阻塞当前线程的执行，并且不会返回协程的执行结果。
- async：async 用于启动一个新的协程，并返回一个 Deferred 对象，它是 Job 的子类，可以通过 await 函数获取协程的执行结果；启动的协程在后台运行，不会阻塞当前线程的执行。
- runBlocking：runBlocking 是一个顶层函数，用于启动一个新的协程并阻塞当前线程，直到协程执行完成； runBlocking 本质上是为了在顶层（如 main 函数）使用协程，以及在测试中使用协程；在生产代码中不推荐使用 runBlocking，因为它会阻塞当前线程，可能导致性能问题。
- withContext：withContext 用于切换协程的上下文，它会创建一个新的协程并在指定的上下文中执行，它会挂起原来的协程，待新协程执行结束后才恢复执行。
3.3.1 launch
public fun CoroutineScope.launch( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit ): Job { val newContext = newCoroutineContext(context) val coroutine = if (start.isLazy) LazyStandaloneCoroutine(newContext, block) else StandaloneCoroutine(newContext, active = true) coroutine.start(start, coroutine, block) return coroutine } 说明：launch 用于启动一个新的协程，并返回一个 Job 对象，该对象代表了这个新协程；启动的协程在后台运行，不会阻塞当前线程的执行，并且不会返回协程的执行结果。
3.3.2 async
public fun <T> CoroutineScope.async( context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T ): Deferred<T> { val newContext = newCoroutineContext(context) val coroutine = if (start.isLazy) LazyDeferredCoroutine(newContext, block) else DeferredCoroutine<T>(newContext, active = true) coroutine.start(start, coroutine, block) return coroutine } 说明：async 用于启动一个新的协程，并返回一个 Deferred 对象，它是 Job 的子类，可以通过 await 函数获取协程的执行结果；启动的协程在后台运行，不会阻塞当前线程的执行。
3.3.3 runBlocking
runBlocking 官方介绍见 → runBlocking。
public actual fun <T> runBlocking(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T { ... val currentThread = Thread.currentThread() val contextInterceptor = context[ContinuationInterceptor] val eventLoop: EventLoop? val newContext: CoroutineContext if (contextInterceptor == null) { // 如果没有指定调度器(dispatcher), 则创建或使用私有事件循环(eventLoop) eventLoop = ThreadLocalEventLoop.eventLoop newContext = GlobalScope.newCoroutineContext(context + eventLoop) } else { eventLoop = (contextInterceptor as? EventLoop)?.takeIf { it.shouldBeProcessedFromContext() } ?: ThreadLocalEventLoop.currentOrNull() newContext = GlobalScope.newCoroutineContext(context) } val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop) coroutine.start(CoroutineStart.DEFAULT, coroutine, block) return coroutine.joinBlocking() } 说明：runBlocking 是一个顶层函数，用于启动一个新的协程并阻塞当前线程，直到协程执行完成； runBlocking 本质上是为了在顶层（如 main 函数）使用协程，以及在测试中使用协程；在生产代码中不推荐使用 runBlocking，因为它会阻塞当前线程，可能导致性能问题。
3.3.4 withContext
public suspend fun <T> withContext( context: CoroutineContext, block: suspend CoroutineScope.() -> T ): T { // ... return suspendCoroutineUninterceptedOrReturn sc@ { uCont -> val oldContext = uCont.context val newContext = oldContext.newCoroutineContext(context) newContext.ensureActive() if (newContext === oldContext) { val coroutine = ScopeCoroutine(newContext, uCont) return@sc coroutine.startUndispatchedOrReturn(coroutine, block) } if (newContext[ContinuationInterceptor] == oldContext[ContinuationInterceptor]) { val coroutine = UndispatchedCoroutine(newContext, uCont) withCoroutineContext(newContext, null) { return@sc coroutine.startUndispatchedOrReturn(coroutine, block) } } val coroutine = DispatchedCoroutine(newContext, uCont) block.startCoroutineCancellable(coroutine, coroutine) coroutine.getResult() } } 说明：withContext 用于切换协程的上下文，它会创建一个新的协程并在指定的上下文中执行，它会挂起原来的协程，待新协程执行结束后才恢复执行。
3.4 协程启动模式源码（CoroutineStart）
public enum class CoroutineStart { // 立即执行协程体 DEFAULT, // 只有在需要的情况下运行, 需要调用job.start()函数才启动协程 LAZY, // 立即执行协程体, 但在开始运行前无法取消 ATOMIC, // 立即在当前线程执行协程体, 直到第一个suspend函数调用(启动较快) UNDISPATCHED; // ... } 4 协程应用
4.1 协程作用域应用
4.1.1 CoroutineScope
fun main() { println("main-start") CoroutineScope(Dispatchers.Default).launch { for (i in 1..2) { println("CoroutineScope-A-$i") delay(100) } } CoroutineScope(Dispatchers.IO).launch { for (i in 1..2) { println("CoroutineScope-B-$i") delay(100) } } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 打印如下。
main-start main-end CoroutineScope-A-1 CoroutineScope-B-1 CoroutineScope-A-2 CoroutineScope-B-2 说明：结果表明 main、CoroutineScope-A、CoroutineScope-B 并行。
4.1.2 MainScope
fun main() { println("main-start") MainScope().launch(Dispatchers.Default) { test("MainScope-A") } MainScope().launch(Dispatchers.IO) { test("MainScope-B") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end MainScope-B-1 MainScope-A-1 MainScope-A-2 MainScope-B-2 说明：结果表明 main、MainScope-A、MainScope-B 并行。
4.1.3 GlobalScope
fun main() { println("main-start") GlobalScope.launch(Dispatchers.Default, CoroutineStart.DEFAULT) { test("GlobalScope-A") test("GlobalScope-B") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end GlobalScope-A-1 GlobalScope-A-2 GlobalScope-B-1 GlobalScope-B-2 说明：结果表明 main 与 GlobalScope 并行。
4.1.4 lifecycleScope
import android.os.Bundle import androidx.appcompat.app.AppCompatActivity import androidx.lifecycle.lifecycleScope import kotlinx.coroutines.launch class MyActivity: AppCompatActivity() { override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) lifecycleScope.launch { println("lifecycleScope") } } } 说明：使用 lifecycleScope 时，需要在 build.gradle 中引入以下依赖。
implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.1" 4.1.5 viewModelScope
import androidx.lifecycle.ViewModel import androidx.lifecycle.viewModelScope import kotlinx.coroutines.launch class MyViewModel: ViewModel() { init { viewModelScope.launch { println("viewModelScope") } } } 说明：使用 viewModelScope 时，需要在 build.gradle 中引入以下依赖。
implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.5.1' 4.1.6 子协程
fun main() { println("main-start") CoroutineScope(Dispatchers.Default).launch { test("CoroutineScope-A") launch(Dispatchers.Default) { // 也可以通过async启动子协程 test("CoroutineScope-B") } launch(Dispatchers.Default) { // 也可以通过async启动子协程 test("CoroutineScope-C") } } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end CoroutineScope-A-1 CoroutineScope-A-2 CoroutineScope-B-1 CoroutineScope-C-1 CoroutineScope-B-2 CoroutineScope-C-2 说明：结果表明 main 与 CoroutineScope-A 并行，CoroutineScope-A 运行结束后，又启动了 GlobalScope-B、CoroutineScope-C 两个子协程，它们又并行。
4.2 协程启动方式应用
4.2.1 launch
fun main() { println("main-start") MainScope().launch(Dispatchers.Default, CoroutineStart.DEFAULT) { test("MainScope") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end MainScope-1 MainScope-2 4.2.2 async
fun main() { println("main-start") MainScope().launch(Dispatchers.Default) { var deferred = async { // 启动子协程 test("MainScope") "async return value" } println("MainScope-xxx") var res = deferred.await() // 获取子协程的返回值, 此处会挂起当前协程, 直到子协程执行完成 println(res) } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end MainScope-xxx MainScope-1 MainScope-2 async return value 说明：结果表明 deferred.await() 会挂起当前协程（MainScope），直到子协程（async）执行完成。
4.2.3 runBlocking
fun main() { println("main-start") runBlocking { var deferred = async { // 启动子协程 test("runBlocking") "async return value" } launch { // 启动子协程 var res = deferred.await() // 获取子协程的返回值, 此处会挂起当前协程, 直到子协程执行完成 println(res) } println("runBlocking-xxx") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start runBlocking-xxx runBlocking-1 runBlocking-2 async return value main-end 说明：结果表明 runBlocking 启动了一个新的协程（runBlocking），并阻塞了当前线程（main），直到协程执行完成；deferred.await() 会挂起当前子协程（async），直到子协程（launch）执行完成。
4.2.4 withContext
1）不使用 withContext 返回值
@OptIn(ExperimentalStdlibApi::class) fun main() { println("main-start") runBlocking(Dispatchers.IO) { println("context1=${coroutineContext[CoroutineDispatcher]}") withContext(Dispatchers.Default) { // 启动子协程, 并挂起当前协程 println("context2=${coroutineContext[CoroutineDispatcher]}") test("withContext") } println("runBlocking-xxx") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start context1=Dispatchers.IO context2=Dispatchers.Default withContext-1 withContext-2 runBlocking-xxx main-end 说明：结果表明 withContext 创建了子协程，并挂起了 runBlocking 协程，直到 withContext 协程执行完毕才恢复执行。
2）使用 withContext 返回值
@OptIn(ExperimentalStdlibApi::class) fun main() { println("main-start") runBlocking(Dispatchers.IO) { println("context1=${coroutineContext[CoroutineDispatcher]}") var res = withContext(Dispatchers.Default) { // 启动子协程, 并挂起当前协程 println("context2=${coroutineContext[CoroutineDispatcher]}") "withContext return value" } println("res=$res") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 打印如下。
main-start context1=Dispatchers.IO context2=Dispatchers.Default res=withContext return value main-end 4.3 Job 应用
Job 状态流程转换如下。（图片来自 Job.kt 源码）
4.3.1 start
fun main() { println("main-start") var job = MainScope().launch(Dispatchers.Default, CoroutineStart.LAZY) { test("MainScope") } job.start() // 注释该行, job不会执行, test中日志将不会打印 println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end MainScope-1 MainScope-2 说明：注释掉 job.start()，job 不会执行，test 中日志将不会打印。
4.3.2 cancel
fun main() { println("main-start") var job = CoroutineScope(Dispatchers.Default).launch { test("CoroutineScope") } job.cancel() println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end CoroutineScope-1 说明：CoroutineScope-2 未打印出来，因为协程执行到一半被取消了。
4.3.3 join
fun main() { println("main-start") var job = CoroutineScope(Dispatchers.Default).launch { test("CoroutineScope") } MainScope().launch(Dispatchers.Default) { println("MainScope-xxx") job.join() // 挂起当前协程, 直到job执行完成 test("MainScope") } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } suspend fun test(tag: String) { for (i in 1..2) { println("$tag-$i") delay(100) } } 打印如下。
main-start main-end MainScope-xxx CoroutineScope-1 CoroutineScope-2 MainScope-1 MainScope-2 说明：结果表明 job.join() 挂起了 MainScope 协程，直到 CoroutineScope 协程执行完毕才恢复执行。
4.4 异常处理应用
4.4.1 try-catch 处理异常
fun main() { println("main-start") CoroutineScope(Dispatchers.IO).launch { try { var a = 1 / 0 } catch (e: Exception) { println(e) } } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 打印如下。
main-start main-end java.lang.ArithmeticException: / by zero 4.4.2 CoroutineExceptionHandler 处理异常
@OptIn(ExperimentalStdlibApi::class) fun main() { println("main-start") var exceptionHandler = CoroutineExceptionHandler { context, throwable -> println("context=${context[CoroutineDispatcher]}, message=${throwable}") } CoroutineScope(Dispatchers.IO + exceptionHandler).launch { var a = 1 / 0 } println("main-end") Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 打印如下。
main-start main-end context=Dispatchers.IO, message=java.lang.ArithmeticException: / by zero 5 协程并发安全
5.1 不安全的并发访问
fun main() { var count = 0 CoroutineScope(Dispatchers.Default).launch { var jobList = List(1000) { // 创建1000个子协程 CoroutineScope(Dispatchers.Default).launch { count++ } } jobList.joinAll() // 挂起当前协程, 直到所有子协程执行完成 println(count) // 期望打印1000, 但每次运行结果不一样, 如：990、981、995等 } Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 5.2 安全的并发访问
安全的并发访问工具主要有 Atomic、Mutex、Semaphore、Channel。
- Atomic：原子操作，主要接口：getAndIncrement、getAndDecrement、getAndAdd、getAndAccumulate、incrementAndGet、decrementAndGet、addAndGet、accumulateAndGet 等。
- Mutex：轻量级锁，主要接口：withLock 等。
- Semaphore：轻量级信号量，主要接口：withPermit 等。
- Channel：并发安全的消息通道，主要接口：send、receive。
5.2.1 Atomic
使用 Java 提供的原子操作类型数据，如：AtomicBoolean、AtomicInteger、AtomicLong、AtomicIntegerArray、AtomicLongArray、AtomicReference、AtomicReferenceArray，可以解决一些并发安全访问的问题。
fun main() { var count = AtomicInteger() CoroutineScope(Dispatchers.Default).launch { var jobList = List(1000) { // 创建1000个子协程 CoroutineScope(Dispatchers.Default).launch { count.getAndIncrement() } } jobList.joinAll() // 挂起当前协程, 直到所有子协程执行完成 println(count.get()) // 打印: 1000 } Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 5.2.2 Mutex
Mutex 是轻量级锁，它的 lock 和 unlock 从语义上与线程锁比较类似，之所以轻量是因为它在获取不到锁时不会阻塞线程，而是挂起等待锁的释放。
fun main() { var count = 0 var mutex = Mutex() CoroutineScope(Dispatchers.Default).launch { var jobList = List(1000) { // 创建1000个子协程 CoroutineScope(Dispatchers.Default).launch { mutex.withLock { count++ } } } jobList.joinAll() // 挂起当前协程, 直到所有子协程执行完成 println(count) // 打印: 1000 } Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 5.2.3 Semaphore
Semaphore 是轻量级信号量，信号可以有多个，协程在获取到信号后即可执行并发操作。
fun main() { var count = 0 var semaphore = Semaphore(1) // 创建一个信号量, 里面只有一个信号 CoroutineScope(Dispatchers.Default).launch { var jobList = List(1000) { // 创建1000个子协程 CoroutineScope(Dispatchers.Default).launch { semaphore.withPermit { count++ } } } jobList.joinAll() // 挂起当前协程, 直到所有子协程执行完成 println(count) // 打印: 1000 } Thread.sleep(1000) // 阻塞当前线程, 避免程序过早结束, 协程提前取消 } 说明：Semaphore 的入参表示信号个数，当 Semaphore 的参数为 1 时， 效果等价与 Mutex。
6 加载网络图片案例
build.gradle 中需要引入以下依赖。
dependencies { implementation 'com.github.bumptech.glide:glide:4.12.0' implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.5.1" ... } AndroidManifest.xml 中需要配置以下权限。
<uses-permission android:name="android.permission.INTERNET" /> MainActivity.kt
package com.zhyan8.kotlinStudy import android.os.Bundle import android.view.View import android.widget.Button import android.widget.ImageView import androidx.appcompat.app.AppCompatActivity import androidx.lifecycle.lifecycleScope import com.bumptech.glide.Glide import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.launch import kotlinx.coroutines.withContext class MainActivity: AppCompatActivity() { private lateinit var imageView: ImageView private lateinit var button: Button override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.activity_main) imageView = findViewById(R.id.imageView) button = findViewById(R.id.btn_back) button.setOnClickListener{ lifecycleScope.launch(Dispatchers.IO) { loadImageFromUrl("https://images.cnblogs.com/cnblogs_com/blogs/787006/galleries/2393602/o_240421081243_g0001.jpg") } } } private suspend fun loadImageFromUrl(url: String) { val bitmap = Glide.with(this@MainActivity) .asBitmap() .load(url) .submit() .get() withContext(Dispatchers.Main) { imageView.visibility = View.VISIBLE button.visibility = View.GONE imageView.setImageBitmap(bitmap) } } } activity_main.xml
<?xml version="1.0" encoding="utf-8"?> <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" tools:context=".MainActivity" android:orientation="vertical" android:gravity="center"> <ImageView android:id="@+id/imageView" android:layout_height="match_parent" android:layout_width="match_parent" android:scaleType="centerCrop" android:visibility="gone" /> <Button android:id="@+id/btn_back" android:layout_width="250dp" android:layout_height="wrap_content" android:text="加载图片" android:textSize="40sp"/> </LinearLayout> 运行效果如下。
声明：本文转自【Kotlin】协程。
