Milyen lehetőségeket kínál a Kotlin az aszinkron…

A Kotlin korutinokat (coroutines) az aszinkron műveletek egyszerűsítésére kínálja, könnyű súlyú áramlásokat kínálva, amelyek nem blokkolják a fő végrehajtási szálat.

Fő lehetőségek:

Szünetet adó függvények: suspend kulcsszóval ellátott függvények, amelyek szüneteltethetők és folytathatók. Nem blokkolják a végrehajtó szálat.
```
suspend fun fetchData(): String {
    delay(1000) // Hosszú művelet szimulálása
    return "Adatok megkapták"
}
```
Korutin építők: Függvények, amelyek a korutinok indítására szolgálnak:
- launch: Új korutint indít és Job-ot ad vissza (nem blokkol).
```
GlobalScope.launch {
    println("Korutin indítva")
}
```
- async: Új korutint indít és Deferred<T>-t ad vissza (.await() hívásakor blokkoló).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // Eredmény várása
```
- runBlocking: Blokkolja az aktuális szálat a korutín befejezéséig (főként hídként használják blokkoló és nem blokkoló kód között, például tesztekben).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
CoroutineContext: Elemek halmaza, amelyek meghatározzák a korutina viselkedését, beleértve a Dispatcher-t és a Job-t.
- Dispatcher: Meghatározza a szálat vagy szálak halmazát, ahol a korutina fut.
Dispatchers: Beépített objektumok a szálak kezelésére:
- Dispatchers.Default: Általános háttér szálak pool-ja.
- Dispatchers.IO: Optimalizált bemenet/kimenet műveletekre (lemezek, hálózati műveletek).
- Dispatchers.Main: A fő UI szál (Android, JavaFX stb.).
- Dispatchers.Unconfined: A korutina a jelenlegi szálon indul, de szünet után bármely szálon folytatódhat.
```
GlobalScope.launch(Dispatchers.IO) {
    // Bemenet/kimenet szálon fut
}
```
Szervezett konkordancia: Elv, amely szerint a korutinoknak van szülőjük (CoroutineScope), és automatikusan törlődnek a szülő törlésekor. Ez megakadályozza az erőforrás szivárgást és megkönnyíti az életciklus kezelését.
```
// A CoroutineScope automatikusan kezeli az alkorutínokat
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// A scope törlésekor minden alkorutín törlődik
scope.cancel()
```
Csatornák: Csatornák az adatok biztonságos átadására a korutinok között. Lehetnek:
- Unbuffered: Csak küldés után fogad.
- Buffered: Több elemet is küldhet, mielőtt blokkolna.
- Conflated: Csak az utolsó küldött elemet tartja meg.
```
val channel = Channel<Int>()

scope.launch {
    for (x in 1..5) channel.send(x)
    channel.close()
}

scope.launch {
    for (y in channel) println(y)
}
```

Flow: Olyan adatfolyam, amely több értéket is kibocsáthat aszinkron módon. Hasonló az RxJava Observable-hez, de könnyebb és a korutinokkal integrált.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // Érték küldése
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // Értékek fogyasztása
}

Ezek a lehetőségek lehetővé teszik az aszinkron kód írását imperatív stílusban, ami olvashatóbbá és karbantarthatóbbá teszi, összehasonlítva a callback-ek vagy Future használatával.

Milyen lehetőségeket kínál a Kotlin az aszinkron műveletek kezelésére?