Créer et exécuter des coroutines dans Kotlin

1. Coroutines à Kotlin
2. Créer un nouveau projet et ajouter des dépendances dans Kotlin
3. Créer et exécuter des coroutines séquentiellement dans Kotlin
4. Créer et exécuter des coroutines simultanément dans Kotlin
5. Conclusion

Ce didacticiel présentera les coroutines et montrera comment elles peuvent être exécutées séquentiellement ou simultanément à l’aide de async-await() dans Kotlin.

Coroutines à Kotlin

Une coroutine peut être considérée comme une procédure sauf qu’elle prend en charge la programmation asynchrone par rapport aux autres procédures normales qui ne prennent en charge que la programmation synchrone.

La programmation asynchrone est une technique par laquelle nous pouvons suspendre l’exécution d’une tâche à un certain point et déléguer l’exécution à une autre tâche pendant que la tâche suspendue attend que certaines tâches en arrière-plan soient exécutées. Ces tâches en arrière-plan peuvent inclure la lecture d’un enregistrement à partir d’une base de données, le téléchargement du contenu d’une page Web et le traitement d’une demande d’utilisateur à partir d’une application.

En programmation synchrone, l’exécution d’une tâche n’est suspendue à aucun moment et le thread est utilisé exclusivement jusqu’à la fin de l’exécution.

Une coroutine représente cette instance d’une routine suspendue. Il peut également être considéré comme un thread, mais une coroutine ne dépend pas du thread sous-jacent car elle peut suspendre et reprendre l’exécution sur différents threads.

Dans ce tutoriel, nous allons apprendre à créer des coroutines séquentielles et concurrentes en veillant à ce que les fonctions async-await() soient exécutées dans le bon ordre.

Créer un nouveau projet et ajouter des dépendances dans Kotlin

Allez dans IntelliJ et sélectionnez File > New > Project. Dans la fenêtre qui s’ouvre, entrez kotlinCoroutines comme nom de projet, choisissez Kotlin dans la section Langue, Gradle dans la section Build System et appuyez sur le bouton Create.

Pour travailler avec des coroutines dans Kotlin, nous devons ajouter les dépendances de coroutine à notre application. Allez dans le fichier build.gradle.kts et assurez-vous d’avoir les dépendances suivantes.

dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.2")
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.2")
    testImplementation(kotlin("test"))
}

Assurez-vous d’avoir une connexion Internet active pour télécharger les dépendances. Une fois les dépendances téléchargées, chargez les modifications Gradle et passez aux étapes suivantes.

Créer et exécuter des coroutines séquentiellement dans Kotlin

Créez le package com/coroutine sous le dossier kotlin, qui sera le package de base de notre application. Créez un fichier Main.kt dans le dossier coroutine, puis copiez et collez le code suivant dans le fichier.

package com.coroutine

import kotlinx.coroutines.async
import kotlinx.coroutines.delay
import kotlinx.coroutines.runBlocking

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

fun main(): Unit = runBlocking {
    val value = async {
        executeProcedureOne()
    }
    value.await()
    val secondValue = async {
        executeProcedureTwo()
    }
    secondValue.await()
}

Dans le code ci-dessus, nous avons défini deux méthodes, executeProcedureOne() et executeProcedureTwo(), qui peuvent être suspendues pour effectuer certaines tâches en arrière-plan. Ceci est réalisé en utilisant le mot-clé suspend, comme indiqué ci-dessus.

Notez que ces deux méthodes peuvent être suspendues sans bloquer le thread sous-jacent.

Nous avons assigné la fonction main à une fonction nommée runBlocking. La fonction runBlocking est une fonction de construction qui crée une coroutine qui s’exécute sur le thread principal et est bloquée jusqu’à ce que les coroutines à l’intérieur de la fonction aient fini de s’exécuter.

Dans la fonction runBlocking, nous avons créé deux fonctions async qui appellent respectivement les méthodes executeProcedureOne() et executeProcedureTwo().

La fonction async est un constructeur de coroutine qui crée une nouvelle coroutine et retourne un Différé. Un Deferred est un futur qui représente une promesse de retourner une valeur, et nous pouvons utiliser await() pour récupérer la valeur.

Notez qu’appeler await() immédiatement après async entraînera la suspension de la coroutine puisque la coroutine interne est en cours d’exécution et reprend une fois qu’elle est terminée.

Le code ci-dessus s’exécute séquentiellement comme les méthodes await() après que chaque fonction async force la coroutine à être suspendue jusqu’à ce qu’elle soit terminée et qu’elle puisse aller aux autres coroutines.

Exécutez le code ci-dessus et notez que executeProcedureOne() est terminé avant executeProcedureTwo() même s’il retarde le plus longtemps. La sortie est comme indiqué ci-dessous.

procedure one executed
procedure two executed

Créer et exécuter des coroutines simultanément dans Kotlin

Commentez le code précédent, et copiez-collez le code suivant dans le fichier Main.kt juste après le commentaire.

suspend fun executeProcedureOne(): Int{
    delay(3000L)
    println("procedure one executed")
    return 50;
}

suspend fun executeProcedureTwo(): Int{
    delay(1000L)
    println("procedure two executed")
    return 30;
}

suspend fun executeProcedures() = coroutineScope{
    val firstValue = async {
        executeProcedureOne()
    }

    val secondValue = async {
        executeProcedureTwo()
    }

    firstValue.await()
    secondValue.await()
}

fun main(): Unit = runBlocking  {
    executeProcedures()
}

Nous avons modifié l’exemple précédent pour qu’il soit concurrent en déplaçant les constructeurs de coroutine async vers une autre fonction suspendable ayant un coroutineScope et wait() après l’exécution des fonctions pour empêcher la suspension d’une coroutine.

La différence entre coroutineScope et runBlocking est que le coroutineScope est suspendu et libère le thread sous-jacent pour continuer à exécuter d’autres tâches.

Exécutez le code ci-dessus et notez que la méthode executeProcedureTwo() est exécutée en premier car elle a moins de retard que la méthode executeProcedureOne(). La sortie est illustrée ci-dessous.

procedure two executed
procedure one executed

Conclusion

Dans ce tutoriel, nous avons appris ce que sont les coroutines et comment les exécuter séquentiellement ou simultanément en exploitant les fonctions async-await(). Nous avons également appris plusieurs concepts communs dans le contexte des coroutines, notamment la programmation asynchrone, la programmation synchrone, la fonction runBlocking{} et la fonction coroutineScope{}.