Quali meccanismi fornisce Kotlin per lavorare con…

Coroutines (Coroutines): Fusi leggeri che consentono di scrivere codice asincrono in stile imperativo, evitando chiamate bloccanti. Basate su funzioni ripristinabili e non legate a thread nativi.
Dispatchers: Determinano il thread o il pool di thread in cui verrà eseguita la coroutine.
- Dispatchers.Default: Per compiti intensivi in risorse (ad esempio, CPU-bound).
- Dispatchers.IO: Per operazioni di input/output (ad esempio, richieste di rete, lavoro con file).
- Dispatchers.Main: Per eseguire codice nel thread principale (ad esempio, aggiornamento UI in un'app Android).
- Dispatchers.Unconfined: Esegue la coroutine nel thread corrente fino alla prima chiamata a una funzione sospesa.
Funzioni suspend: Funzioni che possono essere sospese e riprese più tardi. Contrassegnate con il modificatore suspend.
Context: Contiene informazioni sulla coroutine, come il dispatcher, il job e il gestore delle eccezioni.
Job: Rappresenta il ciclo di vita della coroutine (in esecuzione, attiva, terminata, annullata). Permette di gestire la coroutine (annullare, attendere il completamento).
Scope: Definisce l'ambito delle coroutine, gestendo il loro ciclo di vita.
MutableStateFlow / SharedFlow: Nella libreria kotlinx.coroutines.flow, consentono di scambiare dati in modo sicuro tra coroutine.
Mutex: Primitive di sincronizzazione per proteggere le sezioni critiche.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Esempio di utilizzo di coroutine e dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Coroutine di lavoro: $i")
            delay(100) // Ritardo non bloccante
        }
    }
    println("Coroutine avviata")
    job.join() // Attende il completamento della coroutine
    println("Coroutine terminata")
}

// Esempio di funzione suspend
suspend fun fetchData(): String {
    delay(1000) // Simulazione di richiesta di rete
    return "Dati ricevuti"
}

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

val mutex = Mutex()
var counter = 0

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

Quali meccanismi fornisce Kotlin per lavorare con calcoli paralleli?