Kotlin сопрограммы «случается раньше» гарантирует?

Предоставляют ли сопрограммы Kotlin какие-либо гарантии «произойдет раньше»?

Например, существует ли гарантия «происходит до» между записью в mutableVarи последующим чтением (потенциально) в другом потоке в этом случае:

suspend fun doSomething() {
    var mutableVar = 0
    withContext(Dispatchers.IO) {
        mutableVar = 1
    }
    System.out.println("value: $mutableVar")
}

Редактировать:

Может быть, дополнительный пример прояснит вопрос лучше, потому что это больше Kotlin-иш (за исключением изменчивости). Является ли этот код потокобезопасным:

suspend fun doSomething() {
    var data = withContext(Dispatchers.IO) {
        Data(1)
    }
    System.out.println("value: ${data.data}")
}

private data class Data(var data: Int)

Код, который вы написали, имеет три доступа к общему состоянию:

var mutableVar = 0                        // access 1, init
withContext(Dispatchers.IO) {
    mutableVar = 1                        // access 2, write
}
System.out.println("value: $mutableVar")  // access 3, read

Три доступа строго упорядочены по порядку, без параллелизма между ними, и вы можете быть уверены, что инфраструктура Kotlin позаботится об установлении границы «случай до того» при передаче в IOпул потоков и обратно в вызывающую сопрограмму.

Вот эквивалентный пример, который может показаться более убедительным:

launch(Dispatchers.Default) {
    var mutableVar = 0             // 1
    delay(1)
    mutableVar = 1                 // 2
    delay(1)
    println("value: $mutableVar")  // 3
}

Поскольку delayэто приостанавливаемая функция, и поскольку мы используем Defaultдиспетчер, поддерживаемый пулом потоков, строки 1, 2 и 3 могут выполняться в разных потоках. Поэтому ваш вопрос о гарантиях « до и после» в равной степени относится и к этому примеру. С другой стороны, в этом случае (я надеюсь) совершенно очевидно, что поведение этого кода соответствует принципам последовательного выполнения.

Сопрограммы в Котлине действительно предоставляются раньше, чем гарантии.

Правило таково: внутри сопрограммы код перед вызовом функции приостановки происходит перед кодом после вызова приостановки.

Вы должны думать о сопрограммах, как если бы они были обычными потоками:

Даже если сопрограмма в Kotlin может выполняться в нескольких потоках, она похожа на поток с точки зрения изменчивого состояния. Никакие два действия в одной и той же сопрограмме не могут быть одновременными.

Источник: https://proandroiddev.com/what-is-concurrent-access-to-mutable-state-f386e5cb8292

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

См. Https://youtrack.jetbrains.com/issue/KT-15514.