Блог

Я думал, что вызов функции «приостановить» из контекста сопрограммы с использованием launch делает вызов асинхронным. Но в приведенном ниже примере я вижу, что 2 вызова placeOrder метода не выполняются в одном потоке один за другим. В чем моя ошибка?

 import kotlinx.coroutines.launch
import kotlinx.coroutines.runBlocking
import java.io.File

fun main() = runBlocking {
    t("1")
    launch {
        t("2")
        placeOrder("C:\Users")
        t("3")
    }
    launch {
        t("12")
        placeOrder("C:\Program Files")
        t("13")
    }
    t("4")
}


fun t(s: String) {
    val currentThread = Thread.currentThread()
    println(s   ": "   currentThread.name   " "       currentThread.id)
}

suspend fun placeOrder(d:String): String {
    t("placeOrder $d")
    val user = createUser(d) // asynchronous call to user service
    val order = createOrder(user) // asynchronous call to order service
    t("placeOrder $d finished")
    return order
}

suspend fun createUser(d:String): String {
    t("createUser $d")
    val toString = File(d).walk().map {
        it.length()
    }.sum().toString()
    t("createUser $d finished")
    return toString
}

suspend fun createOrder(user: String): String {
    t("createOrder $user")
    val toString = File("C:\User").walk().map {
        it.length()
    }.sum().toString()
    t("createOrder $user finished")
    return toString
}
  

Вывод:

 1: main 1
4: main 1
2: main 1
placeOrder C:Users: main 1
createUser C:Users: main 1
createUser C:Users finished: main 1
createOrder 1094020270277: main 1
createOrder 1094020270277 finished: main 1
placeOrder C:Users finished: main 1
3: main 1
12: main 1
placeOrder C:Program Files: main 1
createUser C:Program Files: main 1
createUser C:Program Files finished: main 1
createOrder 5651227104: main 1
createOrder 5651227104 finished: main 1
placeOrder C:Program Files finished: main 1
13: main 1
  

Вместо того, чтобы писать приостановленный ввод-вывод, вы написали блокирующий ввод-вывод:

 File(d).walk().map {
    it.length()
}
  

Ваши функции фактически никогда не приостанавливаются, а вместо этого они блокируют единственный поток, связанный с их runBlocking диспетчером.

Вы не дали своим сопрограммам возможности выполняться одновременно.

Если бы вы применили withContext(IO) { ... } приведенный выше код, вы получили бы параллелизм, но простого старого Java-типа, когда несколько потоков блокируются в операциях ввода-вывода вместе.

Причина такого поведения двоякая:

1. Все ваши сопрограммы выполняются в области runBlocking видимости, которая представляет собой однопоточный цикл событий. Таким образом, это означает, что когда-либо используется только один поток, если не указан другой контекст. ( launch(Dispatchers.IO) в качестве примера)
2. Даже тогда сопрограммы могли бы чередоваться, за исключением того, что ваши сопрограммы вызывают приостанавливающие функции, которые на самом деле должны приостанавливаться. Это означает, что это фактически обычный последовательный вызов функции. Если бы ваши функции включали yield() delay(..) вызов or, вы бы увидели чередование сопрограмм при выполнении.

подпись функции запуска:

 fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job (source)
  

Согласно официальной ссылке на документацию Kotlin:

 When launch { ... } is used without parameters, it inherits the context (and
thus dispatcher) from the CoroutineScope it is being launched from.
  

В вашем случае он наследует контекст основной сопрограммы блокировки выполнения, которая выполняется в основном потоке.
Поскольку контекст сопрограммы включает диспетчер сопрограммы, который определяет, какой поток или потоки соответствующая сопрограмма использует для своего выполнения, вы можете предоставить другой CoroutineContext с помощью конструктора сопрограмм запуска. Например:

 fun main() = runBlocking {
    t("1")
    launch(Dispatchers.Default) {
        t("2")
        placeOrder("C:\Users")
        t("3")
    }
    launch(Dispatchers.Default) {
        t("12")
        placeOrder("C:\Program Files")
        t("13")
    }
    t("4")
}
  

Что касается функций приостановки, приостанавливающая функция — это обычная функция Kotlin с дополнительным модификатором приостановки, который указывает, что функция может приостановить выполнение сопрограммы. Это не делает вызов асинхронным по умолчанию.
Вы можете выполнить код своей функции с помощью пользовательского диспетчера (например, диспетчера ввода-вывода), используя функцию Котлина withContext(), как показано ниже:

 suspend fun get(url: String) = withContext(Dispatchers.IO){/* Code for N/W logic */}
  

Это приведет к выполнению тела функции в отдельном потоке, отличном от контекста вызывающей сопрограммы.

Вот блог из 3 частей, в котором объясняется использование сопрограмм в приложениях для Android: https://medium.com/androiddevelopers/coroutines-on-android-part-i-getting-the-background-3e0e54d20bb

заменить launch на async

читать это

По сути, приведенный выше код выполняется синхронно даже без runBlocking !

Поскольку все сопрограммы запускаются в основной поток, работающий в одном потоке, в конечном итоге вы можете использовать диспетчер ввода-вывода, который использует несколько потоков.

Также обратите внимание, что несколько сопрограмм могут выполняться в одном потоке, но они никогда не выполняются параллельно, они могут отображаться как выполняемые параллельно из-за переключения потоков с одной сопрограммы на другую при запуске или приостановке новой сопрограммы.