Qu'est-ce qu'une coroutine en Kotlin et comment…

La coroutine en Kotlin est une unité légère d'exécution qui permet d'écrire du code asynchrone et non bloquant de manière plus lisible et séquentielle. Elle ressemble à un thread, mais est beaucoup plus légère et peut être créée en grand nombre.

Composants principaux et principes de fonctionnement :

Fonctions Suspendues (Fonctions Suspendables) : Fonctions marquées par le mot-clé suspend, qui peuvent suspendre leur exécution sans bloquer le thread dans lequel elles s'exécutent. Lorsqu'une fonction suspendue termine son opération d'"attente" (par exemple, une requête réseau), elle peut reprendre l'exécution là où elle s'était arrêtée.
Contexte (Contexte de Coroutine) : Ensemble d'éléments contrôlant le comportement de la coroutine. Inclut :
- Job : Descripteur de la coroutine, permettant de gérer son cycle de vie (annulation, attente de fin).
- CoroutineDispatcher : Définit le(s) thread(s) sur lequel(s) la coroutine sera exécutée. Permet de changer de thread.
- CoroutineName : Nom optionnel pour le débogage.
- CoroutineExceptionHandler : Gestionnaire d'exceptions non gérées.
Constructeurs (Builders) : Fonctions qui démarrent l'exécution des coroutines :
- launch : Démarre une nouvelle coroutine sans retourner de résultat. Retourne un Job.
- async : Démarre une nouvelle coroutine qui retourne un résultat (Deferred). Pour obtenir le résultat, on utilise .await().
- runBlocking : Constructeur bloquant, principalement utilisé pour les tests ou l'intégration avec du code bloquant.

Comment cela fonctionne en coulisses :

Les coroutines ne créent pas de threads séparés pour chaque tâche. Au lieu de cela, lorsque la fonction suspend est suspendue, le compilateur génère du code qui sauvegarde l'état actuel des calculs. Lorsque le résultat est disponible, la coroutine reprend sur l'un des threads gérés par CoroutineDispatcher. Cela est réalisé en transformant les fonctions suspend en appels asynchrones avec des continuations, permettant à un seul thread d'exécuter plusieurs coroutines, en changeant entre elles lors de la suspension.

Exemple :

import kotlinx.coroutines.*

fun main() = runBlocking { // Bloque le thread actuel jusqu'à ce que la coroutine à l'intérieur de runBlocking se termine
    println("D'abord")

    launch { // Démarre une nouvelle coroutine en arrière-plan
        delay(1000L) // Retard non bloquant de 1 seconde
        println("Après le retard")
    }

    println("Puis") // Cette ligne s'exécutera avant la fin de la coroutine launch
}

La sortie de ce code sera :

D'abord
Puis
Après le retard

Cela démontre la nature non bloquante de launch et delay.

Qu'est-ce qu'une coroutine en Kotlin et comment fonctionne-t-elle?