Android Academy · Leçon

Coroutines et fonctions suspendues

Écrivez du code asynchrone qui se lit comme du code synchrone. Utilisez des fonctions suspendues, des portées de coroutine et des répartiteurs (IO, Main, Default).

Leçon 3 sur 611 étapes

Coroutines et fonctions suspendues est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 6. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 6 leçons au total.

Le problème : bloquer le thread de l'interface

Android exécute tout le travail de l'interface sur le thread principal. Si vous effectuez une requête réseau ou lisez la base de données sur le thread principal, l'interface se fige jusqu'à la fin de l'opération.

Si l'interface reste figée plus de 5 secondes, Android affiche une boîte de dialogue ANR (App ne répond pas) et l'utilisateur peut forcer la fermeture de votre application.

Que sont les coroutines ?

Les coroutines Kotlin permettent d'écrire du code asynchrone qui ressemble à du code séquentiel — sans rappels ni chaînes RxJava.

Légères — des milliers de coroutines peuvent s'exécuter simultanément
Suspendables — une coroutine peut se mettre en pause et reprendre sans bloquer un thread
Structurées — elles respectent un cycle de vie (périmètre)

Fonctions suspend

Une fonction marquée suspend peut mettre son exécution en pause sans bloquer le thread. Elle ne peut être appelée que depuis une autre fonction suspend ou un périmètre de coroutine.

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000)  // simulates 1 second network call
    return "Data loaded!"
}

fun main() = runBlocking {
    println("Fetching...")
    val result = fetchData()  // suspends here, doesn't block
    println(result)           // Data loaded!
    println("Done")
}

Périmètres de coroutines

Chaque coroutine s'exécute dans un périmètre qui définit son cycle de vie :

viewModelScope — annulé lorsque le ViewModel est supprimé
lifecycleScope — annulé lorsque l'Activity ou le Fragment est détruit
GlobalScope — dure indéfiniment (à éviter)
runBlocking — uniquement pour les tests

launch ou async

Deux façons de démarrer une coroutine :

launch { } — lancement sans attente, sans valeur de retour
async { }.await() — renvoie un résultat que vous pouvez attendre

import kotlinx.coroutines.*

fun main() = runBlocking {
    // launch: no return value
    launch {
        delay(500)
        println("launch done")
    }

    // async: returns a Deferred<T>
    val deferred = async {
        delay(300)
        42
    }
    val result = deferred.await()
    println("async result: $result")
}

Dispatchers : quel thread ?

Les Dispatchers contrôlent le ou les threads sur lesquels la coroutine s'exécute :

Dispatchers.Main — thread de l'interface utilisateur (pour mettre à jour les vues)
Dispatchers.IO — pour les opérations réseau et disque
Dispatchers.Default — pour les tâches exigeant beaucoup de ressources du processeur

Utilisez withContext(Dispatchers.IO) { } pour changer de répartiteur à l'intérieur d'une coroutine.

Exemple avec viewModelScope

Récupérez des données dans un ViewModel sans bloquer l'interface utilisateur :

import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.*

class DataViewModel : ViewModel() {

    fun loadData() {
        viewModelScope.launch {
            // Switch to IO thread for network
            val data = withContext(Dispatchers.IO) {
                // simulate network request
                delay(1000)
                "Result from server"
            }
            // Back on Main thread — safe to update UI
            _uiState.value = data
        }
    }
}

Gestion des erreurs dans les coroutines

Gérez les exceptions dans une coroutine avec try/catch, comme dans du code classique :

viewModelScope.launch {
    try {
        val result = withContext(Dispatchers.IO) {
            api.fetchUser()  // may throw IOException
        }
        _user.value = result
    } catch (e: Exception) {
        _error.value = "Failed: ${e.message}"
    }
}

Coroutines parallèles

Exécutez deux tâches en parallèle et attendez qu'elles soient toutes les deux terminées avec async/await :

viewModelScope.launch {
    // Both run at the same time!
    val userDeferred = async(Dispatchers.IO) { api.getUser() }
    val postsDeferred = async(Dispatchers.IO) { api.getPosts() }

    val user = userDeferred.await()
    val posts = postsDeferred.await()

    _state.value = UiState(user, posts)
}

Vérification rapide

Quel répartiteur de coroutine devez-vous utiliser pour les opérations réseau et de base de données ?

Réponds-y dans la leçon interactive

Récapitulatif : coroutines

Vous pouvez maintenant écrire du code asynchrone sans rappels :

suspend fun — peut se mettre en pause sans bloquer le thread
viewModelScope.launch { } — démarre une coroutine dans un ViewModel
withContext(Dispatchers.IO) — bascule vers un thread d'arrière-plan
async { }.await() — exécute un travail en parallèle et renvoie un résultat
try/catch fonctionne normalement dans les coroutines

Ensuite : le modèle Repository — une séparation claire entre les sources de données.

Gratuit pour commencer

Apprends Kotlin avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 36
Leçons: 152

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Coroutines et fonctions suspendues » est-elle gratuite ?

Oui — le texte complet de « Coroutines et fonctions suspendues » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 6 leçons au total.

Qu'est-ce que j'apprendrai dans « Coroutines et fonctions suspendues » ?

Écrivez du code asynchrone qui se lit comme du code synchrone. Utilisez des fonctions suspendues, des portées de coroutine et des répartiteurs (IO, Main, Default). Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 6.

Combien de temps prend la leçon « Coroutines et fonctions suspendues » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy