Le garanzie "succede prima" delle coroutine di Kotlin?

Le coroutine di Kotlin forniscono garanzie "prima"?

Ad esempio, esiste una garanzia "accade prima" tra la scrittura mutableVare la successiva lettura su (potenzialmente) altro thread in questo caso:

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

Modificare:

Forse un ulteriore esempio chiarirà meglio la domanda perché è più kotlin-ish (tranne che per la mutabilità). Questo codice è thread-safe:

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

private data class Data(var data: Int)

Il codice che hai scritto ha tre accessi allo stato condiviso:

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

I tre accessi sono rigorosamente ordinati in sequenza, senza concorrenza tra loro, e puoi stare certo che l'infrastruttura di Kotlin si occupa di stabilire un limite prima del passaggio al IOpool di thread e di nuovo alla tua routine di chiamata.

Ecco un esempio equivalente che potrebbe forse sembrare più convincente:

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

Poiché delayè una funzione sospendibile e poiché stiamo utilizzando il Defaultdispatcher supportato da un pool di thread, le righe 1, 2 e 3 possono essere eseguite su un thread diverso. Pertanto la tua domanda sulle garanzie prima che si verifichi vale anche per questo esempio. D'altro canto, in questo caso (spero) completamente ovvio che il comportamento di questo codice è coerente con i principi dell'esecuzione sequenziale.

Le coroutine a Kotlin prevedono che avvengano prima delle garanzie.

La regola è: all'interno di una routine, il codice prima di una chiamata di funzione di sospensione si verifica prima del codice dopo la chiamata di sospensione.

Dovresti pensare alle coroutine come se fossero fili regolari:

Anche se una coroutine in Kotlin può essere eseguita su più thread, è proprio come un thread dal punto di vista dello stato mutevole. Non possono essere simultanee due azioni nella stessa procedura.

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

Tornando all'esempio di codice. Catturare vars nei corpi funzione lambda non è la migliore idea, specialmente quando lambda è un coroutine. Il codice prima di un lambda non si verifica prima del codice all'interno.

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