Kādas iespējas piedāvā Kotlin darbam ar asinhronām…

Kotlin nodrošina korutinas (coroutines) asinhronisku operaciju vienkāršošanai, piedāvājot vieglus straumes, kas neblokeē galveno izpildes plūsmu.

Galvenās iespējas:

Suspension Functions: funkcijas ar suspend atslēgvārdu, kuras var tikt pārtrauktas un atsāktas. Tās neblokeē izpildes plūsmu.
```
suspend fun fetchData(): String {
    delay(1000) // Imitē ilgu operāciju
    return "Dati saņemti"
}
```
Coroutines Builders: funkcijas, kas tiek izmantotas korutīnu palaišanai:
- launch: sāk jaunu korutīnu un atgriež Job (neblokeējoši).
```
GlobalScope.launch {
    println("Korutīna palaista")
}
```
- async: sāk jaunu korutīnu un atgriež Deferred<T> (bloke ar .await() izsaukumu).
```
val deferred = GlobalScope.async {
    fetchData()
}
// ...
val result = deferred.await() // gaidām rezultātu
```
- runBlocking: bloķē esošo plūsmu līdz korutīnas pabeigšanai (galvenais izmanto, kā tiltu starp bloķējošo un neblokeējošo kodu, piemēram, testos).
```
runBlocking {
    val data = fetchData()
    println(data)
}
```
CoroutineContext: elementu kopums, kas nosaka korutīnas uzvedību, tostarp Dispatcher un Job.
- Dispatcher: nosaka plūsmu vai plūsmu baseinu, kurā tiek izpildīta korutīna.
Dispatchers: iebūvēti objekti plūsmu pārvaldībai:
- Dispatchers.Default: kopējais fonu plūsmu baseins.
- Dispatchers.IO: optimizēts ievades/izvades operācijām (diski, tīkls).
- Dispatchers.Main: galvenais UI plūsma (Android, JavaFX utt.).
- Dispatchers.Unconfined: sāk korutīnu esošajā plūsmā, bet pēc pārtraukšanas tā var atsākties jebkurā plūsmā.
```
GlobalScope.launch(Dispatchers.IO) {
    // Izpilda ievades/izvades plūsmā
}
```

Structured Concurrency: princips, saskaņā ar kuru korutīnas ir ar vecāku (CoroutineScope) un automātiski tiek atceltas, ja tiek atcelts vecāks. Tas novērš resursu noplūdi un vienkāršo dzīves cikla pārvaldību.

// CoroutineScope automātiski pārvalda bērnu korutīnas
val scope = CoroutineScope(Dispatchers.Default)
val job = scope.launch {
    // ...
}
// Atceļot scope, tiek atceltas visas bērnu korutīnas
scope.cancel()

Channels: kanāli drošai datu pārraidīšanai starp korutīnām. Var būt:
- Unbuffered: saņemšana notiek tikai pēc sūtīšanas.
- Buffered: ļauj sūtīt vairākus elementus pirms bloķēšanas.
- Conflated: glabā tikai pēdējo sūtīto elementu.
```
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: datu plūsma, kas var emitēt vairākas vērtības asinhroni. Līdzīga RxJava Observable, bet vieglāka un integrēta ar korutīnām.

fun simpleFlow(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(100)
        emit(i) // vērtības sūtīšana
    }
}

runBlocking {
    simpleFlow().collect { value -> println(value) } // vērtību patēriņš
}

Šīs iespējas ļauj rakstīt asinhrono kodu imperatīvā stilā, padarot to lasāmāku un uzturamu, salīdzinot ar kolbeku vai Future izmantošanu.

Kādas iespējas piedāvā Kotlin darbam ar asinhronām operācijām?