Programmation asynchrone en Kotlin : guide complet

Programmation asynchrone en Kotlin : Guide complet

La programmation asynchrone est une approche de développement où un programme ne bloque pas l'exécution en attendant la fin d'opérations longues (comme les requêtes réseau, la lecture de fichiers ou les opérations base de données). Au lieu de cela, il continue d'exécuter d'autres tâches, et le résultat est renvoyé plus tard. Dans le monde Kotlin, l'outil principal pour le travail asynchrone est les coroutines — des threads légers qui permettent d'écrire du code asynchrone presque comme du code synchrone.

Dans cet article, nous allons décomposer le fonctionnement de la programmation asynchrone en Kotlin, des bases aux techniques avancées. Vous apprendrez à utiliser efficacement les coroutines, à éviter le blocage et à écrire des applications évolutives.

1. Bases des coroutines en Kotlin

Les coroutines sont un concept clé de la programmation asynchrone en Kotlin. Elles permettent de suspendre l'exécution d'une fonction sans bloquer le thread. La bibliothèque kotlinx.coroutines est utilisée pour travailler avec les coroutines. Voici un exemple minimal :

import kotlinx.coroutines.*

fun main() = runBlocking {    launch {        delay(1000L) // délai non bloquant        println("World!")    }    println("Hello,")}

Dans ce code, runBlocking crée un contexte bloquant pour la coroutine (généralement utilisé uniquement dans main ou les tests), et launch démarre une nouvelle coroutine. La fonction delay est une fonction suspendue qui suspend la coroutine sans bloquer le thread.

Concepts clés :

• CoroutineScope — la portée des coroutines, gère leur cycle de vie.
• CoroutineContext — un ensemble de paramètres (dispatcher, gestionnaire d'exceptions).
• Fonction suspendue — une fonction qui peut être mise en pause et reprise plus tard.

2. Fonctions suspendues et Dispatchers

Les fonctions suspendues sont la base du code asynchrone. Elles peuvent appeler d'autres fonctions suspendues (delay, withContext) et suspendre leur exécution. Exemple :

suspend fun fetchUserData(): String {    delay(2000L) // simulation d'une requête réseau    return "User data"}

fun main() = runBlocking {    val data = async { fetchUserData() }    println("Loading...")    println(data.await()) // attente du résultat}

Les Dispatchers déterminent sur quel thread la coroutine s'exécutera :

• Dispatchers.Default — pour les tâches intensives en CPU (par défaut).
• Dispatchers.IO — pour les opérations d'E/S (réseau, fichiers).
• Dispatchers.Main — pour le thread UI (Android, Swing).
• Dispatchers.Unconfined — non lié à un thread spécifique (rarement utilisé).

Exemple avec changement de dispatcher :

suspend fun loadData(): String = withContext(Dispatchers.IO) {    // exécution d'une opération lourde dans un thread d'arrière-plan    Thread.sleep(1000L) // simulation d'une opération bloquante    "Result"}

L'utilisation du bon dispatcher est d'une importance capitale pour les performances. N'utilisez pas Dispatchers.Main pour les opérations longues — cela bloquerait l'interface utilisateur.

3. Travail avec async/await et les Channels

Pour l'exécution parallèle de plusieurs tâches, utilisez async et await. async retourne un objet Deferred qui peut être attendu :

fun main() = runBlocking {    val result1 = async(Dispatchers.IO) { fetchFromApi("url1") }    val result2 = async(Dispatchers.IO) { fetchFromApi("url2") }    println("Result 1: ${result1.await()}")    println("Result 2: ${result2.await()}")}

suspend fun fetchFromApi(url: String): String {    delay(1000L)    return "Response from $url"