Kokius daugiagijų elementus teikia Kotlin?

Kotlin siūlo šiuos daugiagijinius elementus:

Koručinos: Lengvos srovės, pagrįstos sustabdomomis funkcijomis. Užtikrina asinchroninį ir neblokiruojantį kodo vykdymą.

Koručinų statybininkai: Funkcijos, kurios paleidžia korutinus. Pagrindiniai: launch (paleidžia korutiną be grąžinamos reikšmės), async (paleidžia korutiną ir grąžina Deferred, kurį galima laukti dėl rezultato).

// Pavyzdys naudojant `launch`
GlobalScope.launch {
    println("Sveiki iš korutinės ${Thread.currentThread().name}")
}

// Pavyzdys naudojant `async`
val deferred = GlobalScope.async {
    delay(1000) // Imituojame ilgą operaciją
    "Rezultatas"
}
val result = runBlocking { deferred.await() } // Laukiame rezultato

Dispatchers: Nustato, iš kurio srauto pulso bus vykdoma korutina. Pagrindiniai:
- Dispatchers.Default: Bendras srauto pulso CPU intensyviems užduotims.
- Dispatchers.IO: Srauto pulso blokuojančioms įvesties/išvesties operacijoms (failai, tinklas).
- Dispatchers.Main: Dispečeriu naudotojo sąsajos srautui atitinkamose platformose (Android, Swing).
- Dispatchers.Unconfined: Korutina pradedama dabartiniame sraute, bet gali būti atnaujinta bet kuriame sraute.
```
GlobalScope.launch(Dispatchers.IO) {
    // Vykdyti įvesties/išvesties operacijas
}
```
runBlocking: Korutinos statytoja funkcija, kuri blokuoja dabartinį srautą iki korutinos pabaigos. Naudojama jungiant blokuojantį ir neblokuojantį kodą, dažnai testuose ar pagrindinėse funkcijose:
```
runBlocking {
    launch {
        delay(500)
        println("Baigta ${Thread.currentThread().name}")
    }
    println("Pradėta ${Thread.currentThread().name}")
}
```
suspend funkcijos: Funkcijos, kurių vykdymas gali būti sustabdytas ir atnaujintas. Gali būti iškviestos tik iš kitų suspend funkcijų arba korutinų statytojų:
```
suspend fun doSomething() {
    delay(100) // Sustabdymo pavyzdys
}
```

Job: Paleistos korutinos rankena. Suteikia metodus korutinos gyvavimo ciklo valdymui (atšaukimas, laukimas pabaigos):

val job = GlobalScope.launch {
   // Ilga operacija
}
job.cancel() // Atšaukti korutiną
runBlocking { job.join() } // Laukti pabaigos

CoroutineScope: Apibrėžia korutinų apimtį. Korutinai, paleisti tam tikroje apimtyje, automatiškai atšaukiami atšaukiant apimtį. Padeda valdyti korutinų gyvavimo ciklą:
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Korutina šioje apimtyje
}
scope.cancel() // Atšaukti visas korutinas šioje apimtyje
```

Kanalai (Channel): Primitivai saugiam duomenų perdavimui tarp korutinų. Kanalai gali būti vienpusiai (siuntimui arba gavimui) arba dvipusiai:

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Svarbu uždaryti kanalą
    }
    launch {
        for (y in channel) println(y)
    }
}

Mūtxės (Mutex): Sinchronizacijos primityvai, užtikrinantys išskirtinę prieigą prie bendro ištekliaus. Užtikrina srautų saugumą, leidžiant tik vienai korutinai turėti mūtxę vienu metu:

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

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}

Būsenos (StateFlow, SharedFlow): Duomenų srautai, skirti reaktyviam programavimui ir daugiagijai. StateFlow vaizduoja "šaltą" srautą su dabartine būsena, o SharedFlow — "karštą" srautą plačiai paskirstyti duomenis.