Kotlin Coroutinen "passiert vorher" Garantien?

Bieten Kotlin-Coroutinen Garantien für "Vorheriges"?

mutableVarGibt es in diesem Fall beispielsweise eine "Vorher-passiert" -Garantie zwischen dem Schreiben in und dem anschließenden Lesen eines (möglicherweise) anderen Threads:

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

Bearbeiten:

Vielleicht klärt ein zusätzliches Beispiel die Frage besser, weil es mehr Kotlin-artig ist (mit Ausnahme der Veränderlichkeit). Ist dieser Code threadsicher:

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

private data class Data(var data: Int)

Der von Ihnen geschriebene Code hat drei Zugriffe auf den freigegebenen Status:

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

Die drei Zugriffe sind streng nacheinander angeordnet, ohne dass eine Parallelität zwischen ihnen besteht, und Sie können sicher sein, dass die Infrastruktur von Kotlin dafür sorgt, dass bei der Übergabe an den Thread-Pool und zurück an Ihre aufrufende Coroutine eine Vorab- Kante entsteht IO.

Hier ist ein gleichwertiges Beispiel, das vielleicht überzeugender aussieht:

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

Da delayes sich um eine suspendierbare Funktion handelt und wir den DefaultDispatcher verwenden, der von einem Thread-Pool unterstützt wird, können die Zeilen 1, 2 und 3 jeweils in einem anderen Thread ausgeführt werden. Daher gilt Ihre Frage zu Vorabgarantien auch für dieses Beispiel. Andererseits ist es in diesem Fall (ich würde hoffen) völlig offensichtlich, dass das Verhalten dieses Codes mit den Prinzipien der sequentiellen Ausführung übereinstimmt.

Coroutinen in Kotlin bieten vor Garantien.

Die Regel lautet: Innerhalb einer Coroutine erfolgt der Code vor einem Suspend-Funktionsaufruf vor dem Code nach dem Suspend-Aufruf.

Sie sollten sich Coroutinen so vorstellen, als wären sie normale Threads:

Obwohl eine Coroutine in Kotlin auf mehreren Threads ausgeführt werden kann, ist sie vom Standpunkt eines veränderlichen Zustands aus wie ein Thread. Es können keine zwei Aktionen in derselben Coroutine gleichzeitig ausgeführt werden.

Quelle: https://proandroiddev.com/what-is-concurrent-access-to-mutable-state-f386e5cb8292

Zurück zum Codebeispiel. Das Erfassen von Vars in Lambda-Funktionskörpern ist nicht die beste Idee, insbesondere wenn Lambda eine Coroutine ist. Der Code vor einem Lambda kommt nicht vor dem Code vor.

Siehe https://youtrack.jetbrains.com/issue/KT-15514