深潜Koltin协程:协程构建器
Posted RikkaTheWorld
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了深潜Koltin协程:协程构建器相关的知识,希望对你有一定的参考价值。
系列电子书:传送门
协程构建器
挂起函数需要相互传递 continuation
。它们调用普通函数没有任何问题,但是普通函数不能调用挂起函数。
每个挂起函数都需要由另一个挂起函数调用,而另一个挂起函数又由另一个挂起函数调用,以此类推。但这一切都要从某个地方开始。这个地方就是协程构建器,它是连接正常世界和挂起世界的桥梁。
我们将探讨 kotlinx.continues 库提供的三个基本协程构建器:
launch
runBlocking
async
每种方法都有其用例,让我们来逐一了解。
launch
launch
工作的方式在概念上类似于启动一个新线程(thread
函数)。我们只需启动一个协程,它就会独立运行,就像向空中发射的烟花。下面就是我们如何使用 launch
来启动一个协程:
fun main()
GlobalScope.launch
delay(1000L)
println("World!")
GlobalScope.launch
delay(1000L)
println("World!")
GlobalScope.launch
delay(1000L)
println("World!")
println("Hello,")
Thread.sleep(2000L)
// Hello,
// (1 sec)
// World!
// World!
// World!
launch
函数是 CoroutineScope
接口上的一个扩展函数。它是一个被称为结构化并发机制的重要部分,其目的是在父协程和子协程之间建立关系。在本章的后面,我们将学习结构化并发,但现在我们将通过在 GlobalScope
对象上调用 launch
(之后是 async
)来避免这个概念。这并不是一个标准的实现,因为我们在实际项目中很少使用 GlobalScrope
。
你可能已经注意到的另一件事情:在 main
函数的末尾,我们需要调用 Thread.sleep
,如果不这样做,该函数将会在启动协程后立即结束,因此它们将没有机会完成它们的工作。这是因为 delay
不会阻塞线程:它只是挂起一个协程。你们还记得挂起是如何工作的么? delay
只是设置一个计时器,并挂起一个协程,在一段时间后恢复。如果线程没有被阻塞,那么没有什么事情是繁忙的,那就没有什么事情阻止程序完成(稍后我们将看到,如果我们使用结构化并发,就没有要调用 Thread.sleep
)。
在某种程度上, launch
的工作原理类似 daemon
线程,但是它要廉价的多。维护一个阻塞的线程总是很昂贵的,而维护一个挂起的协程几乎是无成本的(正如前面介绍底层运作的章节中解释的那样)。它们都独立的启动了一些任务,并且需要一些东西来防止程序在它们完成之前结束(在下面例子中,是 Thread.sleep(2000L)
):
fun main()
thread(isDaemon = true)
Thread.sleep(1000L)
println("World!")
thread(isDaemon = true)
Thread.sleep(1000L)
println("World!")
thread(isDaemon = true)
Thread.sleep(1000L)
println("World!")
println("Hello,")
Thread.sleep(2000L)
runBlocking
一般规则下协程不应该阻塞线程,而应该挂起它们,但另一方面,在某些情况下阻塞却是必要的。与 main
函数一样,我们需要阻塞线程,否则程序将过早的结束。对于这种情况,我们可以使用 runBlocking
。
runBlocking
是一个特殊的协程构建器。当它的协程被挂起时(类似于挂起 main
),它会阻塞它已经启动的线程。这意味着 runBlocking
内部的 delay(1000L)
将表现的像 Thread.sleep(1000L)
一样。
fun main()
runBlocking
delay(1000L)
println("World!")
runBlocking
delay(1000L)
println("World!")
runBlocking
delay(1000L)
println("World!")
println("Hello,")
// (1 sec)
// World!
// (1 sec)
// World!
// (1 sec)
// World!
// Hello,
fun main()
Thread.sleep(1000L)
println("World!")
Thread.sleep(1000L)
println("World!")
Thread.sleep(1000L)
println("World!")
println("Hello,")
// (1 sec)
// World!
// (1 sec)
// World!
// (1 sec)
// World!
// Hello,
实际上有几个使用 runBlocking
的特定场景,第一个是 main
函数,我们需要阻塞线程,否则程序将结束。另一个常见用例是单元测试,由于同样的原因,我们需要阻塞线程。
fun main() = runBlocking
// ...
class MyTests
@Test
fun `a test`() = runBlocking
在我们的例子中,我们可以使用 runBlocking
将 Thread.sleep(200)
替换为 delay(2000)
。稍后我们将看到,一旦引入结构化并发,它将会变得更加有用。
fun main() = runBlocking
GlobalScope.launch
delay(1000L)
println("World!")
GlobalScope.launch
delay(1000L)
println("World!")
GlobalScope.launch
delay(1000L)
println("World!")
println("Hello,")
delay(2000L) // still needed
// Hello,
// (1 sec)
// World!
// World!
// World!
runBlocking
曾经是一个重要的构建器,但是在现代编程中很少使用它。在单元测试中,我们经常使用它的接班人 runTest
,它使协程在虚拟时间内运行(这是一个非常有用的测试特性,我们将在协程测试一章中描述)。对于main
函数,我们经常将其挂起(用 suspend
修饰),挂起 main
函数很方便,但现在之后我们将会使用 runBlocking
来运行它。
async
asynce
协程构建器类似于 launch
,但它的设计目的是去产生一个值。这个值需要由 lambda 表达式来返回。 async
函数返回一个 Deferred<T>
类型的对象,其中 T 是生成值的类型。 Deferred
有一个挂起方法 await
,当它准备好时会返回这个值。在下面的例子中,生成的值是42,它的类型是 Int
,因此 async
返回 Deferred<Int>
类型, await
函数返回42的 Int
值。
fun main() = runBlocking
val resultDeferred: Deferred<Int> = GlobalScope.async
delay(1000L)
42
// do other stuff...
val result: Int = resultDeferred.await() // (1 sec)
println(result) // 42
// or just
println(resultDeferred.await()) // 42
就像 launch
构建器一样,async
在被调用时,立马启动协程。因此,它是一种一次启动多个任务,然后等待所有结果的方法。返回的 Deferred
会将生成后的值将存储在自身内部,因此值一旦准备好了,它将立即从 await
返回。但是,如果在值产生之前调用 await
,则该函数会被挂起,直到值准备好。
fun main() = runBlocking
val res1 = GlobalScope.async
delay(1000L)
"Text 1"
val res2 = GlobalScope.async
delay(3000L)
"Text 2"
val res3 = GlobalScope.async
delay(2000L)
"Text 3"
println(res1.await())
println(res2.await())
println(res3.await())
// (1 sec)
// Text 1
// (2 sec)
// Text 2
// Text 3
async
构建器的工作方式与 launch
非常相似,但它对返回值有额外的支持。如果所有 launch
函数都用 async
来替代,代码仍然可以正常工作。但是请不要这样做! async
使用来生成值的,所以如果我们不需要值,我们仍应该使用 launch
。
fun main() = runBlocking
// 不要这么做
GlobalScope.async
delay(1000L)
println("World!")
println("Hello,")
delay(2000L)
// Hello,
// (1 sec)
// World!
async
构建器通常用于并行两个任务,例如从两个不同的地方获取数据,并将它们组合在一起。
scope.launch
val news = async
newsRepo.getNews()
.sortedByDescending it.date
val newsSummary = newsRepo.getNewsSummary()
view.showNews(
newsSummary,
news.await()
)
结构化并发
如果一个协程在 GlobalScope
上启动,程序不会等待它。如上所述,协程不会阻塞任何线程,也不会阻止程序结束,这就是为什么在下面这个例子中,如果我们想要看到 runBlocking
打印出 “World!”,需要在末尾调用额外的 delay
函数。
fun main() = runBlocking
GlobalScope.launch
delay(1000L)
println("World!")
GlobalScope.launch
delay(2000L)
println("World!")
println("Hello,")
// delay(3000L)
// Hello,
我们为什么需要在开始的地方使用 GlobalScope
?这是因为 launch
和 async
都是 CoroutineScope
上的扩展函数。但是,如果你查看这些函数和 runBlocking
的定义,你将看到 block
参数是一个函数类型,其接收类型都是 CoroutineScope
。
fun <T> runBlocking(
context: CoroutineContext = EmptyCoroutineContext,
block: suspend CoroutineScope.() -> T
): T
fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job
fun <T> CoroutineScope.async(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> T
): Deferred<T>
这意味着我们可以摆脱 GlobalScope
,作为替代,可以用 runBlocking
提供的接收器来调用 launch
,使用 this.launch
或者简化的 launch
。因此, launch
将成为 runBlocking
的子协程。正如父子关系那样,父协程的责任是等待所有的子协程,因此 runBlocking
将会挂起,直到所有的子协程完成:
fun main() = runBlocking
this.launch // 和 launch 一样
delay(1000L)
println("World!")
launch 和 this.launch 一样
delay(2000L)
println("World!")
println("Hello,")
// Hello,
// (1 sec)
// World!
// (1 sec)
// World!
父协程为其子协程务提供一个作用域,它们都在该作用域中被调用。这构成了一种被称为结构化并发的关系。下面是父子关系的最重要影响:
- 子协程从父协程继承上下文(但它们也可以重写它,这将在协程上下文一章中解释)
- 父协程挂起,直到所有子协程都完成(这将在任务和子任务等待章节中解释)
- 当父协程被取消时,其所有子协程也会被取消(这将在取消章节中解释)
- 当子协程发生错误时,它也会销毁父协程(这将在异常章节中解释)
注意,与其他协程构建器不同,runBlocking
不是 CoroutineScope
上的扩展函数。这意味着它不能作为子协程:它只能用作根协程(层次结构中所有子协程的父协程)。这意味着 runBlocking
将不同于其他协程的情况。正如我们之前提到的,这与其它构建器非常不同。
更多示例
挂起函数需要从其他挂起函数调用。这一切都需要从一个协程构建器开始。除了 runBlocking
,构建器需要在 CoroutineScope
上启动,在我们的简单示例中, runBlocking
提供了作用域,但在更大的应用程序中,作用域是由我们(我会在构建协程作用域章节中阐述)或者我们所使用的的框架(比如 Ktor 或 android KTX 或 Android)来提供。一旦第一个构建器在一个作用域上启动,其他构建器就可以在第一个构建器的作用域上启动,依次类推,这就是我们应用程序的本质结构。
下面是一些在现实项目中如何使用协程的例子。前两个是后端和 Android 的经典用法。 MainPresenter
是Android 的典型用法。 UserController
则是后端的典型用法。
class NetworkUserRepository(
private val api: UserApi,
) : UserRepository
suspend fun getUser(): User = api.getUser().toDomainUser()
class NetworkNewsRepository(
private val api: NewsApi,
private val settings: SettingsRepository,
) : NewsRepository
suspend fun getNews(): List<News> = api.getNews()
.map it.toDomainNews()
suspend fun getNewsSummary(): List<News>
val type = settings.getNewsSummaryType()
return api.getNewsSummary(type)
class MainPresenter(
private val view: MainView,
private val userRepo: UserRepository,
private val newsRepo: NewsRepository
) : BasePresenter
fun onCreate()
scope.launch
val user = userRepo.getUser()
view.showUserData(user)
scope.launch
val news = async
newsRepo.getNews()
.sortedByDescending it.date
val newsSummary = async
newsRepo.getNewsSummary()
view.showNews(newsSummary.await(), news.await())
@Controller
class UserController(
private val tokenService: TokenService,
private val userService: UserService,
)
@GetMapping("/me")
suspend fun findUser(
@PathVariable userId: String,
@RequestHeader("Authorization") authorization: String
): UserJson
val userId = tokenService.readUserId(authorization)
val user = userService.findUserById(userId)
return user.toJson()
但是有一个问题:挂起函数该怎么办呢? 我们可以挂起,但是我们没有任何作用域。将作用域作为参数传递并不是一个好的解决方案(我们将在作用域函数一章中看到)。我们应该使用 coroutineScope
函数,它是一个挂起函数,为构建起创建一个协程。
使用 coroutineScope
假设在某个存储函数中,你需要异步加载两个资源,如用户数据和文章列表。在本例中,你希望只返回那些用户应该可以看到的文章。为了调用 async
,我们需要一个作用域,但是我们不想把它传递给一个函数。要在挂起函数之外创建作用域,我们可以使用 coroutineScope
函数:
suspend fun getArticlesForUser(
userToken: String?,
): List<ArticleJson> = coroutineScope
val articles = async articleRepository.getArticles()
val user = userService.getUser(userToken)
articles.await()
.filter canSeeOnList(user, it)
.map toArticleJson(it)
coroutineScope
只是一个挂起函数,它为 lambda 表达式创建一个作用域。该函数返回 lambda 表达式,这个 lambda 可以返回任何内容(如 let、run、use、runBlocking)。在上面的例子中,lambda 表达式返回 List<ArticleJson>
,所以 getArticlesForUser
也返回该类型。
coroutineScope
是在挂起函数内部需要作用域时使用的标准函数。这真的很重要,它的设计方法非常适合这个用例,但是要分析它,我们首先要学习一些关于上下文、取消和异常处理的知识,这就是为什么该函数将在后面的专门章节(协程作用域函数)中详细解释。
我们还可以开始将挂起的 main
函数与 coroutineScope
一起使用,这是 runBlocking
的主流替换方案:
suspend fun main(): Unit = coroutineScope
launch
delay(1000L)
println("World!")
println("Hello,")
// Hello,
// (1 sec)
// World!
这张图显示了 kotlinx.couroutines 库使用的不同元素。我们通常从作用域或者 runBlocking
开始。在这些函数中,我们可以调用其他构建器或挂起函数。我们不能在挂起函数上运行构建器,所以我们使用协程作用域函数(例如 coroutineScope
)
总结
这些知识对于使用大多数 Kotlin 协程来说已经足够了。在大多数情况下,我们只是使用挂起函数来调用其它挂起函数或普通函数。如果我们需要引入并发,我们可以使用 coroutineScope
包装函数,并在其作用域上使用构建器。我们将在后面的部分中学习如何构建这样的一个作用域,但对于大多数项目来说,它只需要定义一次,之后就很少涉及了。
虽然我们已经学会了基本知识,但是还有很多东西要学习。在下一章中,我们将深入探讨协程。我们将学习使用不同的上下文,如何处理取消、异常,如何测试协程,等等。还有很多很棒的功能等着我们去发现。
以上是关于深潜Koltin协程:协程构建器的主要内容,如果未能解决你的问题,请参考以下文章