Aké hlavné triedy existujú v Kotlin Coroutines?

Hlavné triedy a koncepty v Kotlin Coroutines:

• CoroutineScope: Určuje životný cyklus corutín, ktoré sú v ňom spustené. Umožňuje zrušiť všetky dcérske corutíny.

• Job: Predstavuje odkaz na corutínu. Umožňuje sledovať jej stav, počkať na jej ukončenie, zrušiť ju.

• Deferred: Špeciálny typ Job, ktorý predstavuje hodnotu, ktorá bude dostupná neskôr. Používa sa pre asynchrónne výpočty, ktoré vracajú výsledok. Výsledok možno získať pomocou funkcie .await().

• Dispatcher: Určuje vlákno alebo pool vlákien, v ktorom sa vykonáva corutína. Hlavné dispatcher-ové:

  • Dispatchers.Default: Optimalizované pre CPU-intenzívne úlohy. Používa spoločný pool vlákien.
  • Dispatchers.IO: Optimalizované pre I/O operácie (sieť, disk). Používa vhodný počet vlákien.
  • Dispatchers.Main: Hlavné vlákno UI. Na aktualizáciu UI. Dostupné na platformách ako Android a iných s príslušnou závislosťou.
  • Dispatchers.Unconfined: Spúšťa corutínu v aktuálnom vlákne, ale ju obnoví v akomkoľvek vlákne, ktoré obnoví suspending-funkciu.

• Suspending function: Funkcia označená kľúčovým slovom suspend a môže byť pozastavená a obnovená neskôr. Môže volať iné suspending-funkcie.

• runBlocking: Blokuje aktuálne vlákno do ukončenia všetkých corutín v jeho oblasti. Používa sa hlavne na testovanie a v main funkciách.

• launch: Spúšťa novú corutínu bez blokovania aktuálneho vlákna a vracia Job.

• async: Spúšťa novú corutínu bez blokovania aktuálneho vlákna a vracia Deferred.

Príklad použitia:

// Príklad použitia CoroutineScope, launch a Dispatchers.IO
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Vytvorenie CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // Spustenie corutíny v IO dispatcher-i
    val job: Job = scope.launch {
        // Vykonanie sieťovej požiadavky alebo inej I/O operácie
        delay(1000) // Napodobnenie práce
        println("Corutína skončila v ${Thread.currentThread().name}")
    }

    // Čakanie na ukončenie corutíny
    job.join()
    println("Hlavná funkcia skončila")
}

// Príklad použitia async a Deferred
import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferredSum: Deferred<Int> = async {
        delay(500)
        1 + 1
    }

    // Čakanie na výsledok
    val result = deferredSum.await()
    println("Výsledok je: $result")
}