Programmation asynchrone en Kotlin : guide complet pour débutants

Formateur Python en ligne pour débutants

Apprenez Python facilement sans surcharge théorique. Résolvez des tâches pratiques avec vérification automatique et écrivez du code directement dans le navigateur.

Start Course

Introduction à la programmation asynchrone en Kotlin

Les applications modernes exigent des performances élevées et une grande réactivité. La programmation asynchrone permet d'effectuer des opérations longues (requêtes réseau, lecture de fichiers, travail avec des bases de données) sans bloquer le thread principal d'exécution. En Kotlin, on utilise pour cela un mécanisme puissant et élégant : les coroutines.

Contrairement aux threads traditionnels, les coroutines sont légères, gérées au niveau du langage et ne nécessitent pas d'énormes ressources système. Cela en fait un outil idéal pour écrire du code asynchrone facile à lire et à maintenir. Dans ce guide, nous allons décomposer les concepts fondamentaux de la programmation asynchrone en Kotlin à partir de zéro.

1. Bases des coroutines : qu'est-ce que c'est et comment ça fonctionne ?

Une coroutine est une instance d'une opération de calcul suspendable. Elle peut être suspendue à un point du code et reprise à un autre, sans bloquer le thread. Pour travailler avec les coroutines, il est nécessaire d'ajouter la bibliothèque kotlinx.coroutines.

Ajout de la dépendance

Ajoutez dans le fichier build.gradle.kts :

dependencies {    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")}

Première coroutine

Pour lancer une coroutine, on utilise le builder launch. Il lance une nouvelle coroutine en arrière-plan.

import kotlinx.coroutines.*

fun main() = runBlocking { // runBlocking bloque le thread principal pour attendre les coroutines    println("Début : ${Thread.currentThread().name}")

    launch { // lancement d'une nouvelle coroutine        delay(1000L) // suspend pendant 1 seconde (ne bloque pas le thread !)        println("Coroutine : ${Thread.currentThread().name}")    }

    println("Fin : ${Thread.currentThread().name}")}

Sortie :

Début : mainFin : mainCoroutine : main

Remarquez : delay est une fonction suspend qui suspend la coroutine, mais ne bloque pas le thread. Pendant que la coroutine "dort", le thread peut exécuter un autre code.

2. Fonctions suspend : les blocs de construction de l'asynchrone

Une fonction suspend est une fonction qui peut être suspendue et reprise plus tard. Ces fonctions ne peuvent être appelées qu'à partir d'autres fonctions suspend ou d'une coroutine. Elles sont marquées par le mot-clé suspend.

Exemple de fonction suspend

import kotlinx.coroutines.*

suspend fun fetchData(): String {    delay(2000L) // simulation d'une longue requête réseau    return "Données reçues"}

fun main() = runBlocking {    println("Demande de données...")    val result = fetchData() // appel d'une fonction suspend depuis une coroutine    println(result)}

Exécution parallèle avec async/await

Si vous devez exécuter plusieurs tâches en parallèle, utilisez le builder async. Il retourne un Deferred — un objet qui stocke le résultat futur. On obtient le résultat avec await().

import kotlinx.coroutines.*

suspend fun loadUser(): String {    delay(1000L)    return "Utilisateur : Ivan"}

suspend fun loadPosts(): String {    delay(1500L)    return "Posts : Actualités, Articles"}

fun main() = runBlocking {    val time = measureTimeMillis {        val userDeferred = async { loadUser() }        val postsDeferred = async { loadPosts() }

        println(userDeferred.await())        println(postsDeferred.await())    }    println("Temps total : $time ms") // ~1500 ms (temps maximum des deux)}

Sans async, les tâches s'exécuteraient séquentiellement et prendraient ~2500 ms. L'exécution parallèle a réduit le temps à ~1500 ms.