Java 执行DB操作时，Kotlin协程或任何协程是否会阻止线程？

我正在努力学习Java/Kotlin中的协同程序与线程。根据我的理解，至少在线程内部调用DB操作时，它会阻塞线程本身，并等待DB的响应，以使其解锁。另一方面，协同程序是“轻量级线程”，但根据我的研究，它们只是线程中的“例程”

---

因此，如果我将协同路由与DB操作一起使用，它是否也会阻止线程，因此线程内运行的其他协同路由将被阻止？？？

是的，调用长时间运行的函数将阻止协同路由运行的线程

在您的示例中，如果有一个长时间运行的db操作，您可以编写如下函数

suspend fun writeToDb(data: Data) = withContext(Dispatchers.IO) {
    // write data to db here
    // return result
}

scope.launch(Dispatchers.main) {
    val result = writeToDb(data)
    if (result == success) {
         // todo
    }
}

suspend fun dontDoThis() {
    timeConsumingFunction()
}

fun timeConsumingFunction() {
    // execute long running operation in current thread
}

您可以像这样从UI线程安全地调用它

suspend fun writeToDb(data: Data) = withContext(Dispatchers.IO) {
    // write data to db here
    // return result
}

scope.launch(Dispatchers.main) {
    val result = writeToDb(data)
    if (result == success) {
         // todo
    }
}

suspend fun dontDoThis() {
    timeConsumingFunction()
}

fun timeConsumingFunction() {
    // execute long running operation in current thread
}

使函数

挂起

不会自动使其非阻塞。例如，如果你有这样的东西

suspend fun writeToDb(data: Data) = withContext(Dispatchers.IO) {
    // write data to db here
    // return result
}

scope.launch(Dispatchers.main) {
    val result = writeToDb(data)
    if (result == success) {
         // todo
    }
}

suspend fun dontDoThis() {
    timeConsumingFunction()
}

fun timeConsumingFunction() {
    // execute long running operation in current thread
}

---

timeConsumingFunction

中没有任何挂起功能，因此在

dontDoThis

中修改的

suspend

是冗余的（IDE会警告您这一点），因此代码将在其启动的任何线程中同步运行。

是，调用长时间运行的函数将阻止运行协同路由的线程

在您的示例中，如果有一个长时间运行的db操作，您可以编写如下函数

suspend fun writeToDb(data: Data) = withContext(Dispatchers.IO) {
    // write data to db here
    // return result
}

scope.launch(Dispatchers.main) {
    val result = writeToDb(data)
    if (result == success) {
         // todo
    }
}

suspend fun dontDoThis() {
    timeConsumingFunction()
}

fun timeConsumingFunction() {
    // execute long running operation in current thread
}

您可以像这样从UI线程安全地调用它

suspend fun writeToDb(data: Data) = withContext(Dispatchers.IO) {
    // write data to db here
    // return result
}

scope.launch(Dispatchers.main) {
    val result = writeToDb(data)
    if (result == success) {
         // todo
    }
}

suspend fun dontDoThis() {
    timeConsumingFunction()
}

fun timeConsumingFunction() {
    // execute long running operation in current thread
}

使函数

挂起

不会自动使其非阻塞。例如，如果你有这样的东西

suspend fun writeToDb(data: Data) = withContext(Dispatchers.IO) {
    // write data to db here
    // return result
}

scope.launch(Dispatchers.main) {
    val result = writeToDb(data)
    if (result == success) {
         // todo
    }
}

suspend fun dontDoThis() {
    timeConsumingFunction()
}

fun timeConsumingFunction() {
    // execute long running operation in current thread
}

timeConsumingFunction

中没有任何挂起功能，因此在

dontdotthis

中修改的

suspend

是冗余的（IDE将警告您这一点），因此代码将在启动的任何线程中同步运行