Quali sono le classi principali in Kotlin Coroutines…

Classi e concetti principali in Kotlin Coroutines:

CoroutineScope: Definisce il ciclo di vita delle coroutine lanciate al suo interno. Permette di cancellare tutte le coroutine figlie.
Job: Rappresenta un handle a una coroutine. Permette di monitorarne lo stato, attendere la sua conclusione, cancellarla.
Deferred: Un tipo speciale di Job che rappresenta un valore che sarà disponibile più tardi. Usato per calcoli asincroni che restituiscono un risultato. Il risultato si ottiene con la funzione .await().
Dispatcher: Definisce il thread o il pool di thread in cui viene eseguita la coroutine. I principali dispatcher:
- Dispatchers.Default: Ottimizzato per compiti intensivi in CPU. Usa un pool di thread condiviso.
- Dispatchers.IO: Ottimizzato per operazioni di I/O (rete, disco). Usa un numero appropriato di thread.
- Dispatchers.Main: Il thread principale dell'UI. Per aggiornare l'UI. Disponibile su piattaforme Android e altre con la dipendenza appropriata.
- Dispatchers.Unconfined: Avvia la coroutine nel thread corrente, ma la riprende in qualsiasi thread che riprende la funzione sospending.
Suspending function: Funzione contrassegnata con la parola chiave suspend che può essere sospesa e ripresa più tardi. Può chiamare altre funzioni suspending.
runBlocking: Blocca il thread corrente fino a quando tutte le coroutine nel suo ambito sono terminate. Usato principalmente per test e nel main.
launch: Avvia una nuova coroutine senza bloccare il thread corrente e restituisce un Job.
async: Avvia una nuova coroutine senza bloccare il thread corrente e restituisce un Deferred.

Esempio di utilizzo:

// Esempio di utilizzo di CoroutineScope, launch e Dispatchers.IO
import kotlinx.coroutines.*

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

    // Avvio di una coroutine nel dispatcher IO
    val job: Job = scope.launch {
        // Eseguire una richiesta di rete o altra operazione di I/O
        delay(1000) // Simulazione di lavoro
        println("Coroutine terminata in ${Thread.currentThread().name}")
    }

    // Attendere la fine della coroutine
    job.join()
    println("Funzione main terminata")
}

// Esempio di utilizzo di async e Deferred
import kotlinx.coroutines.*

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

    // Attendere il risultato
    val result = deferredSum.await()
    println("Risultato è: $result")
}

Quali sono le classi principali in Kotlin Coroutines?