Kotlin: Как дождаться выхода сопрограммы из режима ожидания без блокировки запуска?

Для будущих путешественников, которые совершают ту же ошибку, что и я - runBlocking можно использовать не только в main / тестах, но также:

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

Почему-то у меня создалось впечатление, что использовать только для какой-то библиотечной функции - зло, но это не так.

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

private val myScope = CoroutineScope(Dispatchers.Main) 

myScope.launch {

   withContext(Dispatchers.IO) {
        //to stuff in the background
    }

}

Запустив приведенный ниже код, вы увидите, что он печатает 20, а не null.

fun main() {
    callSuspendFun()
}

suspend fun doWorkAndReturnDouble(num: Int): Int {
    delay(1000)
    return num * 2
}

fun callSuspendFun() {
    val coroutineScope = CoroutineScope(Dispatchers.Main)
    coroutineScope.launch {
        var num: Int? = null
        withContext(Dispatchers.IO) {
            val newNum = 10
            num = doWorkAndReturnDouble(newNum)
        }
        println(num)
    }
}

Итак, чтобы вызвать функцию приостановки из функции, не являющейся приостановкой, без использования runBlocking, вам необходимо создать область сопрограммы. А withContext вы ждете выполнения кода.

Вы должны использовать coroutineScope

suspend fun waitFor(): String = coroutineScope {
    proc.outputStream.close()

    var output = ""
    val outputRdr = async { output = proc.inputStream.bufferedReader().use { it.readText() } }
    var error = ""
    val errorRdr = async { error = proc.errorStream.bufferedReader().use { it.readText() } }

    proc.waitFor()

        outputRdr.await()
        errorRdr.await()

    if (proc.exitValue() != 0) {
        throw RuntimeException("Command returned non-zero status: $output${error}")
    }

    return output
}

Вы можете использовать CoroutineScope() с Dispathers.IO, который запустит сопрограмму в фоновом потоке и разгрузит ваше выполнение в этом потоке.

class RunningCommand(private val proc: Process) {

fun waitFor(): String {
    // Starting a new coroutine on Background thread (IO)
    proc.outputStream.close()
    var output = ""
    CoroutineScope(Dispatchers.Unconfined).async {

        val outputRdr = async { output = proc.inputStream.bufferedReader().use { it.readText() } }
        var error = ""
        val errorRdr = async { error = proc.errorStream.bufferedReader().use { it.readText() } }

        proc.waitFor()

        // No need of runBlocking 
        // await() call would wait for completion of its async block
        outputRdr.await() // Execution would block until outputRdr block completion on IO thread
        // At this stage, outputRdr block is completed
        errorRdr.await() // Execution would block until errorRdr block completion on IO thread
        // At this stage, errorRdr block is completed


        if (proc.exitValue() != 0) {
            throw RuntimeException("Command returned non-zero status: $output${error}")
        }
    return@async output
    }
    return output
}

}

Примечание. Если вы вызываете метод waitFor() из любого контекста сопрограммы, вы можете продолжить работу в том же контексте сопрограммы, написав coroutineScope { } вместо CoroutineScope(Dispatchers.IO).launch { }, правильно управляя структурированным параллелизмом.