Aké prvky viacvláknového spracovania poskytuje…

Kotlin poskytuje nasledujúce prvky viacvláknového programovania:

Korutiny: Ľahké vlákna založené na funkciách, ktoré je možné pozastaviť. Zabezpečujú asynchrónne a neblokujúce vykonávanie kódu.

Konštruktory korutín: Funkcie, ktoré spúšťajú korutiny. Hlavné: launch (spúšťa korutinu bez návratovej hodnoty), async (spúšťa korutinu a vracia Deferred, na ktorý sa dá čakať na získanie výsledku).

// Príklad použitia launch
GlobalScope.launch {
    println("Ahoj z korutiny ${Thread.currentThread().name}")
}

// Príklad použitia async
val deferred = GlobalScope.async {
    delay(1000) // Simulujeme dlhú operáciu
    "Výsledok"
}
val result = runBlocking { deferred.await() } // Čakáme na výsledok

Dispatchers: Určujú, na ktorom vlákne bude korutina spustená. Hlavné:
- Dispatchers.Default: Všeobecný pool vlákien pre CPU-intenzívne úlohy.
- Dispatchers.IO: Pool vlákien pre blokujúce operácie vstupu/výstupu.
- Dispatchers.Main: Dispečer pre vlákno používateľského rozhrania na príslušných platformách (Android, Swing).
- Dispatchers.Unconfined: Korutina sa začína v aktuálnom vlákne, ale môže byť obnovená v ľubovoľnom vlákne.
```
GlobalScope.launch(Dispatchers.IO) {
    // Vykonanie vstupu/výstupu
}
```
runBlocking: Funkcia staviteľa korutiny, ktorá blokuje aktuálne vlákno do dokončenia korutiny. Používa sa na spojenie blokujúceho a neblokujúceho kódu, často v testoch alebo hlavnej funkcii.
```
runBlocking {
    launch {
        delay(500)
        println("Dokončené v ${Thread.currentThread().name}")
    }
    println("Spustené v ${Thread.currentThread().name}")
}
```
suspend funkcie: Funkcie, ktorých vykonávanie môže byť pozastavené a obnovené. Môžu byť volané iba z iných suspend funkcií alebo konštruktorov korutín.
```
suspend fun doSomething() {
    delay(100) // Príklad pozastavenia
}
```

Job: Handle na spustenú korutinu. Poskytuje metódy na správu životného cyklu korutiny (zrušenie, čakanie na dokončenie).

val job = GlobalScope.launch {
   // Dlhá operácia
}
job.cancel() // Zrušenie korutiny
runBlocking { job.join() } // Čakanie na dokončenie

CoroutineScope: Určuje oblasť viditeľnosti pre korutiny. Korutiny, spustené v tejto oblasti, sa automaticky zrušia pri zrušení oblasti. Pomáha spravovať životný cyklus korutín.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Korutina v tejto oblasti
}
scope.cancel() // Zrušenie všetkých korutín v tejto oblasti
```

Kanály (Channel): Primitívy na bezpečný prenos dát medzi korutinami. Kanály môžu byť jednostranné (len na odoslanie alebo prijatie) alebo obojstranné.

import kotlinx.coroutines.channels.Channel

val channel = Channel<Int>()

runBlocking {
    launch {
        for (x in 1..5) channel.send(x * x)
        channel.close() // Je dôležité zatvoriť kanál
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutexy (Mutex): Primitívy na synchronizáciu na zabezpečenie exkluzívneho prístupu ku spoločnému zdroju. Zabezpečujú bezpečnosť vlákien, umožňujúc len jednej korutíne vlastniť mutex v danom momente.
```
import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        counter++
    }
}
```
Stavy (StateFlow, SharedFlow): Primitívy na prácu s dátovými tokmi v kontexte reaktívneho programovania a viacvláknového prostredia. StateFlow predstavuje "studený" tok s aktuálnym stavom, zatiaľ čo SharedFlow je "horúci" tok na široké vysielanie dát.

Aké prvky viacvláknového spracovania poskytuje Kotlin?