Quelles sont les principales classes dans Kotlin…

Classes et concepts principaux dans Kotlin Coroutines:

CoroutineScope : Définit le cycle de vie des coroutines lancées à l'intérieur. Permet d'annuler toutes les coroutines enfants.
Job : Représente une poignée vers une coroutine. Permet de suivre son état, d'attendre sa fin, de l'annuler.
Deferred : Un type spécial de Job représentant une valeur qui sera disponible plus tard. Utilisé pour des calculs asynchrones renvoyant un résultat. Le résultat peut être obtenu avec la fonction .await().
Dispatcher : Définit le thread ou le pool de threads dans lequel la coroutine s'exécute. Les principaux délégués:
- Dispatchers.Default : Optimisé pour les tâches intensives en CPU. Utilise un pool de threads partagé.
- Dispatchers.IO : Optimisé pour les opérations d'I/O (réseau, disque). Utilise un nombre approprié de threads.
- Dispatchers.Main : Le thread principal de l'UI. Pour mettre à jour l'UI. Disponible sur Android et autres plateformes avec la dépendance appropriée.
- Dispatchers.Unconfined : Lance la coroutine dans le thread actuel, mais la reprend dans n'importe quel thread qui reprend la fonction suspending.
Suspending function : Fonction marquée avec le mot-clé suspend pouvant être suspendue et reprise plus tard. Peut appeler d'autres fonctions suspending.
runBlocking : Bloque le thread actuel jusqu'à ce que toutes les coroutines dans son scope soient terminées. Utilisé principalement pour les tests et dans les fonctions main.
launch : Lance une nouvelle coroutine sans bloquer le thread actuel et retourne un Job.
async : Lance une nouvelle coroutine sans bloquer le thread actuel et retourne un Deferred.

Exemple d'utilisation:

// Exemple d'utilisation de CoroutineScope, launch et Dispatchers.IO
import kotlinx.coroutines.*

fun main() = runBlocking {
    // Création de CoroutineScope
    val scope = CoroutineScope(Dispatchers.IO)

    // Lancer une coroutine dans le dispatcher IO
    val job: Job = scope.launch {
        // Effectuer une requête réseau ou une autre opération d'I/O
        delay(1000) // Simulation de travail
        println("Coroutine terminée dans ${Thread.currentThread().name}")
    }

    // Attendre la fin de la coroutine
    job.join()
    println("Fonction main terminée")
}

// Exemple d'utilisation de async et Deferred
import kotlinx.coroutines.*

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

    // Attendre le résultat
    val result = deferredSum.await()
    println("Résultat est : $result")
}

Quelles sont les principales classes dans Kotlin Coroutines?