Kotlin 暂停功能是否在单独的线程上运行？

Question

挂起函数在单​​独的线程上运行？ 如果不是，那么性能优势是什么？

suspend fun requestToken():Token {..}  // takes 2 sec to complete
suspend fun createPost (token:Token){..} // takes 3 sec to complete

 suspend fun postItem() {
    val token = requestToken()
    val post =createPost(token)
    processPost(post)
  }

所以，当我们到达 processPost(post) 并且如果挂起函数没有在单独的线程上运行，那么我们必须等待 requestToken() 和 createPost(token) 方法 完成（即 2+3= 5 秒）。按照作者的说法，挂起是异步的，但如果我们不产生任何新线程，那么我们如何实现异步行为？

Answer 1

挂起是异步的

suspend funs 与其调用者同步执行。您实际上要说的是“非阻塞”，这是一个完全不同的故事。

但如果我们不产生任何新线程，那么我们如何实现异步行为？

您默认所有 I/O 必须在某个级别阻塞。这是错误的。非阻塞 I/O 通过将数据推送到发送缓冲区并在接收缓冲区中有数据时接收通知来工作。 suspend fun 通过在将数据推送到发送缓冲区后挂起自身并安装一个回调，该回调将在接收缓冲区中的响应数据准备好时恢复它，从而与此机制挂钩。

Answer 2

暂停点只能在协程上下文中使用，例如：

fun main() {
    delay(1000)
}

不会工作，因为delay 是一个挂起函数，编译器不知道如何在没有协程的情况下处理它。当您确实有协程时，它可以使用称为调度程序的东西来控制线程所有权。挂起意味着线程不再用于执行程序的该部分，而是执行其他操作或空闲。它的工作方式是您可以让多个协程同时工作，而每个协程都没有线程，然后该线程可以执行每个协程的一部分，直到暂停点。通常的想法是，您可以将挂起函数视为具有产生结果的阶段的“生成器”。

suspend fun hello() {
    println("Hello")
    delay(1000) // suspend here, let someone else use the thread while we wait
    println("World")
    delay(1000) // suspend again, we can still use the thread while waiting
    println("done")
}

每次挂起时，它都会使用线程处理另一个函数，直到该挂起并且延迟到期，此时此函数将最终恢复执行直到下一个挂起点或完全完成执行.

这与阻塞代码不同，因为它不会通过将线程置于 wait 状态来浪费线程，而是将其借给另一个函数。这样就不需要创建其他线程来实现并发，因为您仍然可以在没有真正并行性的情况下处理多个函数，而是使用部分函数的并发执行。

协程不一定能保护你免受阻塞，如果你调用Thread.sleep(1000)，它仍然会是一个阻塞调用。程序员有责任对阻塞函数使用挂起等效项，以最大限度地提高这一概念的有效性。

如需了解更多详情，请阅读documentation，因为它非常详细且很有帮助。

Answer 3

一个线程池的后台单线程或多后台线程可以显式声明然后使用，例如作为参数传递，我们称这个参数为“调度器”。关于它的真正酷的事情是，最初从主线程开始，它会自动切换到调度程序线程以在其上执行特定任务，虚拟机在这个地方暂停或中断，而主线程变得更酷畅通无阻，可以在后台有任务时执行其他操作。

一旦任务完成，虚拟机就会回到之前暂停或中断的点，然后从该点恢复执行，但现在也从后台线程返回结果调度器，下面是sn-p的代码：

private val backgroundThread = ThreadPoolExecutor(1, 1, 15L, TimeUnit.SECONDS, LinkedBlockingQueue())

GlobalScope.launch(Dispatchers.Main, CoroutineStart.DEFAULT) {
    postItem(backgroundThread))
}

suspend fun CoroutineScope.postItem(scheduler: ThreadPoolExecutor): Boolean {
    val token = requestToken(scheduler)
    val post = createPost(token, scheduler)
    return processPost(post, scheduler)
}

private suspend fun CoroutineScope.requestToken(scheduler: ThreadPoolExecutor): String {
    val def: Deferred<String?> = async(scheduler.asCoroutineDispatcher(), CoroutineStart.DEFAULT) {
        val token = networkApi.requestToken()
    }

    return def.await() ?: ""
}

private suspend fun CoroutineScope.createPost(token: String, scheduler: ThreadPoolExecutor): String {
    val def: Deferred<String?> = async(scheduler.asCoroutineDispatcher(), CoroutineStart.DEFAULT) {
        val post = networkApi.createPost(token)
    }

    return def.await() ?: ""
}

private suspend fun CoroutineScope.processPost(post: String, scheduler: ThreadPoolExecutor): Boolean {
    val def: Deferred<Boolean?> = async(scheduler.asCoroutineDispatcher(), CoroutineStart.DEFAULT) {
        val result = networkApi.processPost(post)
    }

    return def.await() ?: false
}