Quels mécanismes Kotlin offre-t-il pour le traitement…

Coroutines (Coroutines): Des threads légers qui permettent d'écrire du code asynchrone de manière impérative, en évitant les appels bloquants. Basés sur des fonctions ré-entrant et non liés aux threads natifs.
Dispatchers: Définissent le thread ou le pool de threads où la coroutine sera exécutée.
- Dispatchers.Default: Pour les tâches gourmandes en ressources (par exemple, CPU-bound).
- Dispatchers.IO: Pour les opérations d'entrée/sortie (par exemple, requêtes réseau, travail avec des fichiers).
- Dispatchers.Main: Pour exécuter du code sur le thread principal (par exemple, mise à jour de l'UI dans une application Android).
- Dispatchers.Unconfined: Exécute la coroutine sur le thread actuel jusqu'au premier appel à une fonction suspendue.
Fonctions suspend: Fonctions pouvant être suspendues et reprises plus tard. Marquées avec le modificateur suspend.
Contexte: Contient des informations sur la coroutine, comme le dispatcher, le job et le gestionnaire d'exceptions.
Job: Représente le cycle de vie de la coroutine (en cours, active, terminée, annulée). Permet de gérer la coroutine (annuler, attendre sa fin).
Scope: Définit le périmètre des coroutines, gérant leur cycle de vie.
MutableStateFlow / SharedFlow: Dans la bibliothèque kotlinx.coroutines.flow, permettent d'échanger des données en toute sécurité entre coroutines.
Mutex: Primitive de synchronisation pour protéger les sections critiques.

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Exemple d'utilisation de coroutines et dispatcher
    val job = launch(Dispatchers.Default) {
        repeat(5) { i ->
            println("Coroutine de travail : $i")
            delay(100) // Retard non bloquant
        }
    }
    println("Coroutine lancée")
    job.join() // Attend la fin de la coroutine
    println("Coroutine terminée")
}

// Exemple de fonction suspend
suspend fun fetchData(): String {
    delay(1000) // Simulation d'une requête réseau
    return "Données reçues"
}

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

val mutex = Mutex()
var counter = 0

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

Quels mécanismes Kotlin offre-t-il pour le traitement parallèle?