Kādas daudzprocesu elementus nodrošina Kotlin?

Kotlin nodrošina šādus daudzvirzienu elementus:

Korutinas: Viegls plūds, balstīts uz pauzes funkcijām. Nodrošina asinhronu un neblokējošu koda izpildi.

Korutinu būvētāji: Funkcijas, kas sāk korutinas. Galvenie: launch (sāk korutinu bez atgriešanas vērtības), async (sāk korutinu un atgriež Deferred, ko var gaidīt rezultātam).

// Piemērs `launch` izmantošanai
GlobalScope.launch {
    println("Sveiki no korutinas ${Thread.currentThread().name}")
}

// Piemērs `async` izmantošanai
val deferred = GlobalScope.async {
    delay(1000) // Ilga operācija imitēta
    "Rezultāts"
}
val result = runBlocking { deferred.await() } // Gaidām rezultātu

Dispatchers: Nosaka, no kura pavediena pulta tiks izpildīta korutina. Galvenie:
- Dispatchers.Default: Kopējais pavedienu pults CPU-intensīviem uzdevumiem.
- Dispatchers.IO: Pavedienu pults bloķējošām I/O operācijām (faili, tīkls).
- Dispatchers.Main: Dispečers lietotāja saskarnes plūsmai atbilstošās platformās (Android, Swing).
- Dispatchers.Unconfined: Korutina tiek palaista pašreizējā pavedienā, bet var atsākties jebkurā pavedienā.
```
GlobalScope.launch(Dispatchers.IO) {
    // I/O izpilde
}
```
runBlocking: Korutinas būvētāja funkcija, kas bloķē pašreizējo pavedienu līdz korutinas beigām. Lieto bloķējoša un neblokējoša koda apvienošanai, bieži testos vai galvenajās funkcijās:
```
runBlocking {
    launch {
        delay(500)
        println("Beidzās ${Thread.currentThread().name}")
    }
    println("Sākās ${Thread.currentThread().name}")
}
```
suspend funkcijas: Funkcijas, kuru izpilde var tikt pārtraukta un atsākta. Tiek izsauktas tikai no citām suspend funkcijām vai korutinu būvētājiem:
```
suspend fun doSomething() {
    delay(100) // Pārtraukšanas piemērs
}
```

Job: Palaistās korutinas rokturis. Nodrošina metodes korutinas dzīves cikla pārvaldībai (atsaukšana, gaidīšana pabeigšanai):

val job = GlobalScope.launch {
   // Ilga operācija
}
job.cancel() // Atsaukt korutinu
runBlocking { job.join() } // Gaidīt pabeigšanu

CoroutineScope: Nosaka korutinu apgabalu. Korutinas, kas sākas noteiktā apgabalā, automātiski tiek atceltas, ja apgabals tiek atcelts. Palīdz pārvaldīt korutinu dzīves ciklu:
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Korutina šajā apgabalā
}
scope.cancel() // Atcelt visas korutinas šajā apgabalā
```

Kanāli (Channel): Primitīvi drošai datu pārraidīšanai starp korutīnām. Kanāli var būt vienvirziena (nosūtīšanai vai saņemšanai) vai divvirziena:

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Svarīgi aizvērt kanālu
    }
    launch {
        for (y in channel) println(y)
    }
}

Mūķes (Mutex): Sinhronizācijas primitīvi, nodrošinot ekskluzīvu piekļuvi kopējam resursam. Nodrošina pavedienu drošību, ļaujot tikai vienai korutīnai vienlaikus turēt mūķi:

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

val mutex = Mutex()
var counter = 0

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

Stāvokļi (StateFlow, SharedFlow): Datu plūsmas reaktīvai programmēšanai un daudzpavedienu kontekstā. StateFlow attēlo "aukstu" plūsmu ar pašreizējo stāvokli, bet SharedFlow — "karstu" plūsmu datu plašsaziņai.