kotlin汇总7-Coroutines

最新推荐文章于 2025-05-22 18:22:30 发布

翻译最新推荐文章于 2025-05-22 18:22:30 发布 · 1k 阅读

文章标签：

#线程 #kotlin

kotlin 专栏收录该内容

17 篇文章

订阅专栏

本文介绍了Kotlin 1.1中Coroutines的基本概念及其在异步编程中的应用。Coroutines通过挂起操作避免线程阻塞，简化了复杂的异步编程任务。文章详细解释了挂起函数的定义和使用，并探讨了Coroutines的内部机制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在kotlin1.1，Coroutines还处于实验阶段。
有些API启动耗时操作比如：网络IO，文件流IO，CPU/GPU要求高的工作，它们会导致调用阻塞直到操作完成。Coroutines通过一种更便宜，更容易控制的suspension(挂起)操作，来避免线程阻塞。

Coroutines把复杂的运算移到了libraries,因而简化了异步编程。在Coroutine中，程序逻辑可以顺序表达（同步），底层的libraries可以帮我们完成异步操作，我们只需要在异步回调中编写我们的代码就完成了，可以在不同的线程订阅相关的事情，执行计划，代码就像顺序执行一样简单。

像其他语言中的大多数异步机制都可以通过coroutines实现。包括C#和ECMAScript的async/await,Go的channels和select, C#和Python的generator/yeild.

阻塞VS挂起
基本上，coroutines可以挂起运算而不会阻塞线程。阻塞线程通常代价昂贵，特别是在高负载的情况下，因为在真实的情境下，仅仅会很少的几个线程会在运行，所以阻塞其中一个线程会导致很多重要的工作会被延迟。

换句话说，Coroutine基本上是无代价的。不需要切换上下文，也不需要任何OS的参与。在这基础上，suspension可以在很大程度上被使用者library控制,作为一个library的开发者，我们可以决定suspension的时候做什么，比如优化/打印/拦截，完全可以根据我们自己的需要。

不同的地方是，Coroutines不能被随时挂起，仅仅是在调用函数的时候。

通过suspend定义一个挂起函数

suspend fun doSomething(foo: Foo): Bar {
    ...
}

在kotlinx.coroutines中有

fun <T> async(block: suspend () -> T)

所以我们可以如下调用

async {
    doSomething(foo)
    ...
}

但是我们需要注意，不能在一个普通的函数如main()中调用挂起函数

fun main(args: Array<String>) {
    doSomething() // ERROR: Suspending function called from a non-coroutine context 
}

而且挂起函数可以是虚函数，可以被子类覆写

interface Base {
    suspend fun foo()
}

class Derived: Base {
    override suspend fun foo() { ... }
}

使用@RestrictsSuspension注释可以使用者定义新的挂起方式，最经典的例子是

@RestrictsSuspension
@SinceKotlin("1.1")
public abstract class SequenceBuilder<in T> internal constructor() {
    /**
     * Yields a value to the [Iterator] being built.
     *
     * @sample samples.collections.Sequences.Building.buildSequenceYieldAll
     * @sample samples.collections.Sequences.Building.buildFibonacciSequence
     */
    public abstract suspend fun yield(value: T)

    /**
     * Yields all values from the `iterator` to the [Iterator] being built.
     *
     * The sequence of values returned by the given iterator can be potentially infinite.
     *
     * @sample samples.collections.Sequences.Building.buildSequenceYieldAll
     */
    public abstract suspend fun yieldAll(iterator: Iterator<T>)

    /**
     * Yields a collections of values to the [Iterator] being built.
     *
     * @sample samples.collections.Sequences.Building.buildSequenceYieldAll
     */
    public suspend fun yieldAll(elements: Iterable<T>) {
        if (elements is Collection && elements.isEmpty()) return
        return yieldAll(elements.iterator())
    }