Hogyan szinkronizáljuk a korutinokat Androiden…

Az Androidban a korutinok szinkronizálására több megközelítés is létezik, a konkrét feladattól függően:

Join: Egy másik korutina befejezésének várása.

// Az első korutina indítása
val job1 = CoroutineScope(Dispatchers.Default).launch {
    delay(1000)
    println("Job 1 kész")
}

// A második korutina indítása
val job2 = CoroutineScope(Dispatchers.Default).launch {
    delay(500)
    println("Job 2 kész")
}

// Mindkét korutina befejezésének várása
job1.join()
job2.join()

println("Minden munka kész")

Await: Egy aszinkron művelet eredményének várása, amit Deferred reprezentál.

// Aszinkron művelet, ami eredményt ad vissza
val deferredResult = CoroutineScope(Dispatchers.Default).async {
    delay(1000)
    "Eredmény az async-ból"
}

// Eredmény várása
val result = deferredResult.await()
println(result)

CoroutineScope.coroutineScope: Egy új hatókör létrehozása, ami csak az összes gyermekkorutina befejezése után ér véget. Strukturált konkurencia esetén hasznos.

suspend fun doParallelWork() {
    coroutineScope { // Új strukturált konkurencia hatókör létrehozása
        launch { delay(1000); println("Feladat 1 kész") }
        launch { delay(500); println("Feladat 2 kész") }
    } // Ez a pont csak akkor érhető el, ha a feladat 1 és 2 befejeződött
    println("Minden párhuzamos feladat kész")
}

Aktorok szemiantikája (Channel): Üzenetcsere és hozzáférés szinkronizálása módosítható adatokhoz korutinok között.

// Létrehozunk egy csatornát az Int típushoz
val channel = Channel<Int>()

CoroutineScope(Dispatchers.Default).launch {
    // Adatok küldése a csatornára
    for (i in 1..5) {
        channel.send(i)
    }
    channel.close() // A csatorna bezárása küldés után
}

CoroutineScope(Dispatchers.Default).launch {
    // Adatok fogadása a csatornáról
    for (value in channel) {
        println("Kaptam $value")
    }
}

Mutex: A közös erőforrás exkluzív hozzáférésének biztosítása.

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock { // Mutex megszerzése
        counter++
        // A mutex automatikusan felszabadul, amikor kilépünk a blokkból
    }
}

A módszer kiválasztása attól függ, pontosan mit kell szinkronizálni: a befejezést, eredményt, párhuzamos feladatokat, adatok cseréjét vagy exkluzív hozzáférést. A coroutineScope az alapértelmezett ajánlott megközelítés strukturált konkurencia esetén.

Hogyan szinkronizáljuk a korutinokat Androiden?