协程基础

在Kotlin中,协程是使用 suspend关键字定义的函数。这意味着该函数可以在执行期间暂停,并由另一个协程恢复执行。

协程可以使用await关键字暂停自身并恢复其他协程的执行。 await只能在suspend函数中使用。

例如:

suspend fun doSomething() { 
    println("Doing something...") 
    delay(1000)  // Delays for 1000 ms 
}

suspend fun main() {
    println("Start")
    doSomething() 
    println("End")
}

上面的例子会按顺序打印"Start"、"Doing something..."和"End"。

协程上下文

每个协程都运行在一个协程上下文中,它维护其自己的调用栈和局部变量。当协程被暂停时,其上下文也会被保留,以便在恢复时可以继续执行。

协程可以通过协程构建器来创建,coroutineScope{}函数用于定义一个协程作用域。在这个范围内启动的所有协程都会在该作用域结束时自动取消。

suspend fun main() { 
    println("Start")
    
    coroutineScope {
        launch { 
            delay(1000) 
            println("Coroutine 1") 
        }
        
        launch { 
            delay(500) 
            println("Coroutine 2") 
        }
    } 
    
    println("End") 
}

这个例子会打印:

Start Coroutine 2 Coroutine 1 End

两个协程同时启动,但由于延迟不同,它们的打印顺序不同。coroutineScope确保两个协程都在其作用域结束前完成。

协程也可以使用async并发执行任务,并使用await获取结果。接下来说一下串行化,互斥的概念。

串行化和互斥

有时我们需要确保协程按特定顺序执行,或者不会同时访问共享的资源。这可以通过以下两种方式实现:

串行化:使用runBlocking { ... }或coroutineScope { ... }启动的协程会按顺序执行,前一个协程完成后,下一个协程才会开始。
互斥:使用mutex.lock()获取锁,执行临界区代码,然后使用mutex.unlock()释放锁。其他协程在获取锁之前会暂停。

例如:

val mutex = Mutex()

suspend fun doSomething1() { 
    mutex.lock() 
    println("Doing something 1...") 
    delay(1000) 
    mutex.unlock() 
}

suspend fun doSomething2() { 
    mutex.lock() 
    println("Doing something 2...")
    delay(1000)
    mutex.unlock() 
} 

fun main() = runBlocking {
    println("Start")
    launch { doSomething1() }
    launch { doSomething2() }
    println("End") 
}

这个例子会串行化两个协程,并打印:

Start Doing something 1... Doing something 2... End

如果没有互斥锁,输出将是不确定的,两个协程可能会同时访问共享资源。

在本文中,我们探讨了如何使用Kotlin协程进行高效的并发编程。我们学习了协程的基本内容、协程上下文、以及如何使用锁实现串行化和互斥。

协程是一种强大的工具,可以用更少的资源实现并发,从而提高应用程序的效率和性能。相比于传统的线程,协程更轻量级,支持更高的并发度。

接下来我们再介绍几个Kotlin协程的高级主题:

通道(Channels)

通道是协程之间的通信机制。它们用于在协程之间发送数据或事件。在某种意义上,通道类似于阻塞队列,但更加轻量级。

有几种类型的通道:

rendezvous通道:发送方暂停直到接收方准备好接收消息。
缓冲通道:通道有一个容量,发送方会在容量用完之前继续发送。
定时通道:指定一个时间段,如果在该时间段内消息未被接收,则该消息将被丢弃。
通道操作符:有许多操作符可以组合通道,如.filter(),.map(),.reduce()等。

例如:

fun main() = runBlocking {
    val channel = Channel<Int>()
    launch { 
        for (x in 1..5) channel.send(x * x) 
    }
    repeat(5) { 
        println(channel.receive()) 
    } 
}

这个例子会打印平方数1到25,发送方会在接收方准备好之前暂停。

协程异常处理

在协程中,当一个子协程抛出异常时,异常会向上传播并取消其父协程。我们可以在协程作用域中使用catch块来处理异常。

例如:

fun main() = runBlocking {
    val job = launch {
        launch { 
            delay(1000) 
            println("Coroutine 1") 
            throw ArithmeticException() 
        }
        launch { 
            delay(500) 
            println("Coroutine 2") 
        }
    }
    job.join()
}

fun main() = runBlocking {
    val job = launch {
        try {
            launch { 
                delay(1000) 
                println("Coroutine 1") 
                throw ArithmeticException() 
            }
            launch { 
                delay(500) 
                println("Coroutine 2") 
            }
        } catch (e: ArithmeticException) {
            println("Caught exception!")
        }
    }
    job.join()
}

第一个例子会打印 Coroutine 2然后Crash,因为异常会向上传播。

第二个例子会打印:

Coroutine 2 Caught exception!

因为catch块处理了异常,父协程不会被取消。

协程作业(Job)

协程作业表示一个协程,可以用来管理其生命周期。我们可以使用job.join()等待作业执行完成,使用job.cancel()取消作业,也可以使用job.isActive检测作业是否处于活跃状态。

作业还具有层次结构 - 启动的子作业变成父作业的子作业。当父作业完成或取消时,所有子作业也会被取消。

这给我们带来了一种方便组织和管理相关协程的方式。

玖叶教程网

前端编程开发入门

使用Kotlin协程进行高效的并发编程