Jaké prvky vícevláknového zpracování poskytuje…

Kotlin poskytuje následující prvky vícevláknového programování:

Korutiny: Lehká vlákna založená na pozastavitelných funkcích. Zajišťují asynchronní a neblokující provádění kódu.

Stavitelé korutin: Funkce, které spouštějí korutiny. Hlavní: launch (spouští korutinu bez návratové hodnoty), async (spouští korutinu a vrací Deferred, na který lze čekat na získání výsledku).

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

// Příklad použití async
val deferred = GlobalScope.async {
    delay(1000) // Simulujeme dlouhou operaci
    "Výsledek"
}
val result = runBlocking { deferred.await() } // Čekáme na výsledek

Dispatchers: Určují, na jakém vláknovém poolu bude korutina spuštěna. Hlavní:
- Dispatchers.Default: Obecný pool vláken pro CPU-intenzivní úkoly.
- Dispatchers.IO: Pool vláken pro blokující operace vstupu/výstupu.
- Dispatchers.Main: Dispečer pro vlákno uživatelského rozhraní na příslušných platformách (Android, Swing).
- Dispatchers.Unconfined: Korutina začíná ve stávajícím vlákně, ale může být obnovena v libovolném vlákně.
```
GlobalScope.launch(Dispatchers.IO) {
    // Vykonání vstupu/výstupu
}
```
runBlocking: Funkce stavitele korutiny, která blokuje aktuální vlákno do dokončení korutiny. Používá se ke spojení blokujícího a neblokujícího kódu, často v testech nebo hlavních funkcích.
```
runBlocking {
    launch {
        delay(500)
        println("Dokončeno v ${Thread.currentThread().name}")
    }
    println("Spuštěno v ${Thread.currentThread().name}")
}
```
suspend funkce: Funkce, jejichž provádění může být pozastaveno a obnoveno. Mohou být volány pouze z jiných suspend funkcí nebo stavitelů korutin.
```
suspend fun doSomething() {
    delay(100) // Příklad pozastavení
}
```

Job: Handle na spuštěnou korutinu. Poskytuje metody pro správu životního cyklu korutiny (zrušení, čekání na dokončení).

val job = GlobalScope.launch {
   // Dlouhá operace
}
job.cancel() // Zrušení korutiny
runBlocking { job.join() } // Čekání na dokončení

CoroutineScope: Určuje oblast viditelnosti pro korutiny. Korutiny spuštěné v této oblasti jsou automaticky zrušeny při zrušení oblasti. Pomáhá spravovat životní cyklus korutin.
```
val scope = CoroutineScope(Dispatchers.Default)
scope.launch {
    // Korutina v této oblasti
}
scope.cancel() // Zrušení všech korutin v této oblasti
```

Kanály (Channel): Primitivy pro bezpečný přenos dat mezi korutinami. Kanály mohou být jednostranné (pouze pro odesílání nebo přijímání) nebo obousměrné.

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é zavřít kanál
    }
    launch {
        for (y in channel) println(y)
    }
}

Mutexy (Mutex): Primitivy synchronizace pro zajištění exkluzivního přístupu ke sdílenému zdroji. Zajišťují bezpečnost vláken, umožňují pouze jedné korutině vlastnit mutex v daném okamžiku.

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): Primitivy pro práci s datovými proudy v kontextu reaktivního programování a vícevláknového prostředí. StateFlow představuje "studený" proud s aktuálním stavem, zatímco SharedFlow je "horký" proud pro široké vysílání dat.

Jaké prvky vícevláknového zpracování poskytuje Kotlin?