Coroutines à Kotlin | AU NOUVEAU BLOG

Dans les applications modernes, en particulier celles impliquant des requêtes réseau, des E/S de fichiers ou des calculs complexes, la gestion des opérations asynchrones est essentielle pour maintenir la réactivité et les performances. Traditionnellement, les développeurs utilisaient des rappels, des threads, des contrats à terme et AsyncTask sous Android pour gérer les tâches asynchrones. Cependant, ces méthodes entraînent souvent plusieurs défis.

Ce diagramme explique brièvement la différence entre l’exécution de tâches « synchrone » et « asynchrone ».

Défis des appels asynchrones

1. Rappels : Les rappels sont des fonctions passées en arguments à d’autres fonctions, à exécuter après la fin d’une tâche. Cela peut conduire à un « enfer des rappels » ou à une « pyramide du malheur », où les rappels imbriqués deviennent difficiles à lire et à maintenir.
2. Sujets : Les threads permettent une exécution parallèle mais entraînent des frais généraux liés à la gestion de la création de threads, de la synchronisation et de problèmes potentiels tels que l’épuisement des threads.
3. Futurs et promesses : Les contrats à terme offrent un moyen de gérer les résultats asynchrones, mais peuvent s’avérer fastidieux, en particulier lors de l’enchaînement de plusieurs opérations asynchrones.
4. AsyncTask (spécifique à Android) : AsyncTask était un moyen courant d’effectuer des opérations en arrière-plan sous Android sans bloquer le thread principal. Cependant, il présente plusieurs inconvénients :
   Fuites de mémoire : Si un `AsyncTask` n’est pas correctement géré, cela peut provoquer des fuites de mémoire en conservant une référence au fichier englobant `Activity` ou `Fragment`.
   Modifications de configuration : `AsyncTask` ne gère pas les modifications de configuration (comme les rotations d’écran) avec élégance, ce qui entraîne des plantages potentiels ou une perte de résultats.
   La gestion du cycle de vie: Gérer le cycle de vie de `AsyncTask` est complexe et sujet aux erreurs, en particulier avec des tâches imbriquées ou multiples.

Pourquoi nous avons besoin de coroutines et ce qu’elles résolvent

Les coroutines Kotlin offrent un moyen plus gérable de gérer les opérations asynchrones en vous permettant d’écrire du code non bloquant de manière séquentielle. Ils fournissent:

• Concurrence simplifiée : Les coroutines éliminent le besoin de rappels, réduisent la complexité et facilitent la lecture et la maintenance du code.
• Concurrence structurée : Les coroutines fournissent une approche structurée de la concurrence, où le cycle de vie des coroutines est lié à leur portée, garantissant une annulation et une gestion des ressources appropriées.
• Fils légers : Les coroutines sont légères, vous permettant d’en exécuter des milliers simultanément sans la surcharge des threads traditionnels.
• Solutions spécifiques à Android :
  • Sensibilisation au cycle de vie : Avec des portées de coroutine liées aux composants du cycle de vie comme viewModelScopevous pouvez facilement gérer les cycles de vie des coroutines, évitant ainsi les fuites de mémoire et garantissant une annulation correcte.
  • Opérations de sécurité principale : En utilisant Dispatchers.Mainvous pouvez mettre à jour l’interface utilisateur en toute sécurité à partir de coroutines sans bloquer le thread principal.
  • Gestion des modifications de configuration : Les coroutines peuvent gérer de manière transparente les modifications de configuration en utilisant des étendues qui respectent le cycle de vie Android.

Création de coroutines

Kotlin propose plusieurs façons de créer et de gérer des coroutines. Les constructeurs de coroutines les plus courants sont launch, asyncet withContext.

lancement

Le ‘launchLa fonction ` crée une nouvelle coroutine qui exécute un bloc de code de manière asynchrone. Il renvoie un Job représentant le cycle de vie de la coroutine.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        println("Coroutine started")
        delay(1000) // Simulate a task with delay
        println("Coroutine completed")
    }

    println("Main thread continues to execute")
    job.join() // Wait for the coroutine to complete
    println("Main thread waits for the coroutine to finish")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val deferred = async {
        println("Async computation started")
        delay(1000) // Simulate a long-running computation
        42 // Computation result
    }

    println("Main thread continues to execute")
    val result = deferred.await() // Await the result of the computation
    println("Async computation result: $result")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Main) {
        println("Running on Main Dispatcher")

        val data = withContext(Dispatchers.IO) {
            println("Fetching data on IO Dispatcher")
            delay(1000) // Simulate network request
            "Data from network"
        }

        println("Received data: $data")
    }
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    coroutineScope {
        launch {
            delay(1000)
            println("Task 1 from coroutineScope")
        }
        launch {
            delay(1500)
            println("Task 2 from coroutineScope")
        }
    }
    println("coroutineScope is over")
}

import kotlinx.coroutines.*

fun main() {
    GlobalScope.launch {
        delay(1000)
        println("Task from GlobalScope")
    }
    Thread.sleep(1500) // Ensure the coroutine has time to complete
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    supervisorScope {
        launch {
            delay(500)
            println("Task from supervisor scope")
        }
        launch {
            delay(1000)
            throw RuntimeException("Failure in child coroutine")
        }
    }
    println("Supervisor scope completed")
}

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

class MyViewModel : ViewModel() {
    fun fetchData() {
        viewModelScope.launch {
            // Perform a network request
            delay(1000)
            println("Data fetched")
        }
    }
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    // Launch a coroutine and get its Job
    val job = launch {
        println("Coroutine started")
        delay(1000) // Simulate a task
        println("Coroutine completed")
    }

    println("Main thread continues to execute")
    // Join the job to wait for coroutine completion
    job.join()
    println("Main thread waits for the coroutine to finish")
}

import kotlinx.coroutines.*

suspend fun fetchData(): String {
    delay(1000) // Simulate network request
    return "Data from network"
}

fun main() = runBlocking {
    val data = fetchData()
    println(data)
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        // Perform CPU-intensive task
    }
    launch(Dispatchers.IO) {
        // Perform I/O-intensive task
    }
    launch(Dispatchers.Main) {
        // Update UI
    }
    launch(Dispatchers.Unconfined) {
        // Resume in the caller thread until the first suspension point
    }
}