Milliseid võimalusi pakub Kotlin asünkroonsete…

Kotlin pakub korutinas (coroutines) lihtsustamaks asünkroonseid operatsioone, pakkudes kergeid vooge, mis ei blokeeri peamist täitmisvoogu.

Peamised võimalused:

Suspension Functions: funktsioonid koos suspend märksõnaga, mida saab peatada ja uuesti alustada. Need ei blokeeri täitmisvoogu.
```
suspend fun fetchData(): String {
    delay(1000) // Imiteerib pikka operatsiooni
    return "Andmed saadud"
}
```
Coroutines Builders: funktsioonid, mida kasutatakse korutinate käivitamiseks:
- launch: käivitab uue korutina ja tagastab Job (mitteblokeeriv).
```
GlobalScope.launch {
    println("Korutina käivitatud")
}
```
- async: käivitab uue korutina ja tagastab Deferred<T> (blokeerib .await()-ga).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // ootab tulemust
```
- runBlocking: blokeerib praeguse voolu kuni korutina lõppemiseni (peamiselt kasutusel sildade loomiseks blokeeriva ja mitteblokeeriva koodi vahel, nt testides).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
CoroutineContext: elementide kogum, mis määrab korutina käitumise, sh Dispatcher ja Job.
- Dispatcher: määrab voolu või voogude paki, kus korutina täidetakse.
Dispatchers: sisseehitatud objektid voogude haldamiseks:
- Dispatchers.Default: üldine taustavoogude pult.
- Dispatchers.IO: optimeeritud sisendi/väljundi operatsioonidele (ketas, võrk).
- Dispatchers.Main: peamine UI voog (Android, JavaFX jms).
- Dispatchers.Unconfined: käivitab korutina praeguses voos, kuid pärast peatamist võib ta jätkata mis tahes voos.
```
GlobalScope.launch(Dispatchers.IO) {
    // Täidetakse sisendi/väljundi voos
}
```

Structured Concurrency: põhimõte, mille kohaselt on korutinalt tütar (CoroutineScope) ja need tühistatakse automaatselt, kui tühistatakse vanem. See aitab vältida ressursside lekkimist ja lihtsustab elutsükli haldamist.

// CoroutineScope haldab automaatselt tütar korutinasid
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// Kui scope tühistatakse, tühistatakse kõik tütar korutinasid
scope.cancel()

Channels: kanalid turvaliseks andmeedastuseks korutinate vahel. Võivad olla:
- Unbuffered: vastuvõtt toimub ainult pärast saatmist.
- Buffered: võimaldab saata mitu elementi enne blokeerimist.
- Conflated: hoiab ainult viimase saadetud elemendi.
```
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: andmevoog, mis võib emitida mitu väärtust asünkroonselt. Sarnane RxJava Observable-le, kuid kergem ja integreeritud korutinatega.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // väärtuse saatmine
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // väärtuste tarbimine
}

Need võimalused võimaldavad kirjutada asünkroonset koodi imperatiivses stiilis, muutes selle loetavamaks ja hooldatavamaks võrreldes kolbekite või Future kasutamisega.

Milliseid võimalusi pakub Kotlin asünkroonsete operatsioonide jaoks?