La programmation asynchrone avec les coroutines

Qu’est-ce qu’une bibliothèque tierce ?

Lorsque l’on crée un programme complexe, un langage de programmation seul n’est pas toujours suffisant. Il n’est pas rare de lui ajouter des bibliothèques tierces.

Une bibliothèque tierce est une bibliothèque (c’est-à-dire du code) écrite par d’autres développeurs et réutilisable dans nos propres programmes.

L’objectif d’une bibliothèque tierce est de nous faire gagner du temps en bénéficiant de l’expertise d’autres développeurs. En effet, nous pouvons réutiliser du code métier ou du code graphique sans avoir besoin de l’écrire nous-mêmes.

Utiliser des bibliothèques tierces est une pratique très répandue. Parfois, l’utilisation est payante, d’autres fois, elles sont mises à disposition gratuitement.

Dans quel cas a-t-on besoin d’une bibliothèque tierce ?

Les raisons peuvent être multiples. Par exemple :

Quand utiliser la programmation asynchrone ?

Pour construire un programme en Kotlin, il convient d’utiliser de nombreux concepts, dont des fonctions et des classes si l’on souhaite faire de la programmation orientée objet.

Les fonctions écrites dans le cadre d’un programme doivent, généralement, répondre à un besoin spécifique et proposer un traitement qui peut être de nature très diverse : lire ou écrire dans un fichier, faire un appel réseau, rechercher un élément dans un tableau, lire ou insérer des données dans une base de données, etc.

Toutes ces opérations peuvent être très rapides ou très longues en fonction du contexte. On imagine par exemple que rechercher un élément dans un tableau de dix cases ne prend pas le même temps que rechercher un élément dans un tableau de plusieurs milliers de cases. Bien évidemment, dans le cadre de la recherche d’éléments dans un tableau, il existe des algorithmes performants pour tenter de réduire le nombre d’opérations et donc limiter le temps de traitement. Par exemple, dans un tableau trié contenant énormément de cases, on privilégiera probablement une recherche dichotomique plutôt qu’une recherche séquentielle.

Malheureusement, nous...

Ajouter les coroutines dans un projet

Les coroutines ne sont pas incluses dans le langage Kotlin. En effet, les développeurs du langage considèrent que certaines fonctionnalités ne sont pas systématiquement utilisées par les développeurs. Aussi, pour réduire la taille des programmes, certains éléments sont distribués à côté. C’est le cas entre autres des coroutines.

Pour bénéficier des coroutines dans nos programmes, il convient d’ouvrir le fichier "build.gradle.kts" du projet IntelliJ IDEA. Actuellement, il ressemble à ceci :

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile 
 
plugins { 
   kotlin("jvm") version "1.4.10" 
   application 
}  
 
group = "me.rolan" 
version = "1.0-SNAPSHOT" 
 
repositories {  
   mavenCentral() 
}  
 
dependencies {  
   testImplementation(kotlin("test-junit")) 
}  
 
tasks.withType<KotlinCompile>(){ 
   kotlinOptions.jvmTarget = "1.8" 
}  
 
application {  
   mainClassName = "MainKt" 
} 

Dans la section dependencies, il faut...

Créer des coroutines

Pour créer et lancer une coroutine, on utilise ce qu’on appelle un constructeur de coroutines (coroutine builder). Dans le cadre de cette section, nous allons en voir trois : runBlocking, launch et async.

import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
  runBlocking { 
 
  } 
} 

import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
  println("Before coroutine") 
 
  runBlocking { 
     println("In coroutine") 
  }  
 
  println("After coroutine") 
} 

Before coroutine 
In coroutine 
After coroutine 

fun main() 
{ 
 println("Before coroutine") 
 
 runBlocking {  
   println("coroutine : Before sleep") 
   Thread.sleep(1000) 
   println("coroutine : After sleep") 
 }  
 
 println("After coroutine") 
} 

Before coroutine 
coroutine : Before sleep 
coroutine : After sleep 
After coroutine 

import kotlinx.coroutines.GlobalScope 
import kotlinx.coroutines.launch 
 
fun main() 
{ 
 GlobalScope.launch { 
 
 } 
} 

import kotlinx.coroutines.GlobalScope 
import kotlinx.coroutines.launch 
 
fun main() 
{ 
 println("Before coroutine") 
 
 GlobalScope.launch {  
   println("coroutine : Before sleep") 
   Thread.sleep(1000) 
   println("coroutine : After sleep") 
 }  
 
 println("After coroutine") ...

Annuler et synchroniser des coroutines

Dans les exemples précédents utilisant les trois constructeurs runBlocking, launch et async, nous n’avons stocké le résultat que pour le constructeur async afin d’attendre la fin de la coroutine.

Il est également possible de stocker le résultat du constructeur launch dans une variable. L’objet renvoyé est de type Job. Tout comme l’objet renvoyé par le constructeur async (pour mémoire, le type de cet objet est Deferred, mais ce type hérite du type Job).

Nous avons eu un aperçu de l’utilité d’un objet de type Job grâce au constructeur async. Il permet non seulement d’attendre la fin de l’exécution de la coroutine, mais aussi d’obtenir de précieuses informations sur celle-ci et de la manipuler.

import kotlinx.coroutines.GlobalScope ...

Des coroutines dans des coroutines

Il est possible de lancer des coroutines dans des coroutines. Une relation de parenté est alors créée entre elles, elle est importante pour bien comprendre leur fonctionnement. La coroutine qui contient est appelée parent tandis que la coroutine contenue est appelée enfant.

Une coroutine parent est terminée uniquement lorsque ses coroutines enfants sont également terminées ou annulées. 

Soit une coroutine qui lance elle-même deux coroutines qui sont mises en pause à l’aide de l’instruction delay :

import kotlinx.coroutines.delay 
import kotlinx.coroutines.launch 
import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
 runBlocking {  
   println("Parent coroutine") 
 
   launch {  
     println("First child coroutine") 
     delay(1000) 
     println("End of first child coroutine") 
   } 
   launch {  
     println("Second child coroutine") 
     delay(1000) 
     println("End of second child coroutine") 
   }  
 
   println("End of parent coroutine") 
 }  
 
 println("End of program") 
} 

Ici, il n’est pas nécessaire de recourir à la classe GlobalScope pour utiliser la fonction launch, car nous sommes déjà dans une coroutine grâce au constructeur...

La gestion des erreurs dans une coroutine

import kotlinx.coroutines.delay 
import kotlinx.coroutines.launch 
import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
runBlocking {  
   println("Parent coroutine") 
 
   launch {  
     println("First child coroutine") 
     delay(1000) 
     println("End of first child coroutine") 
   }  
 
   launch {  
     println("Second child coroutine") 
     delay(500) 
 
     try 
 ...

Ajouter des paramètres aux constructeurs

Il est possible de passer deux paramètres aux constructeurs de coroutines que nous avons vus jusqu’à maintenant : un contexte et une option de démarrage.

Changer de contexte

Pourquoi vouloir changer de contexte au sein d’une coroutine ?

Pour diverses raisons, cela peut être nécessaire. Prenons deux exemples.

Le besoin d’un changement de contexte dans une coroutine peut venir de la nécessité de changer le thread dans lequel la coroutine s’exécute à l’aide d’un objet de type Dispatchers. Imaginons une coroutine lancée à l’aide du constructeur launch dont le but est de consommer une API web. Puisqu’il s’agit d’une opération d’entrée/sortie, le mieux est de lancer cette coroutine dans un thread dédié qui tourne en arrière-plan à l’aide du contexte Dispatchers.IO. Cependant, une fois l’appel terminé et le résultat parsé et interprété, on souhaite mettre à jour l’interface graphique du logiciel. Pour manipuler l’interface graphique d’un logiciel, il convient de retourner dans le thread dédié à cette interface graphique. Pour cela, on a la possibilité de changer le contexte de la coroutine actuelle afin que l’interface graphique puisse être manipulée sans risque. Dans ce cas précis, changer le contexte peut se faire en utilisant le Dispatchers.Main.

Le besoin d’un changement de contexte dans une coroutine peut aussi venir de la nécessité...

L’échange de données entre coroutines

Deux éléments clés du langage Kotlin le leur permettent : les channels et les flows.

val channel = Channel<Int>(3) 

import kotlinx.coroutines.channels.Channel 
import kotlinx.coroutines.delay 
import kotlinx.coroutines.launch 
import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
 runBlocking { 
   val channel = Channel<Int>(3) 
 
   launch { 
     for (i in 1..3) 
     { 
       println("Sending the value $i") 
       channel.send(i) 
       delay(1000) 
     } 
   }  
 
   launch { 
     val dataReceived = channel.receive() 
     println("Receiving the value $dataReceived") 
   } 
 }  
 
 println("End of program") 
} 

Sending the value 1 
Receiving the value 1 
Sending the value 2 
Sending the value 3 
End of program 

import kotlinx.coroutines.channels.Channel 
import kotlinx.coroutines.delay 
import kotlinx.coroutines.launch 
import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
 runBlocking { 
   val channel = Channel<Int>(3) 
 
   launch { 
     for (i in 1..3) 
     { 
       println("Sending the value $i") 
       channel.send(i) 
       delay(1000) 
     } 
   }  
 
   launch { 
       repeat(3) { 
       val dataReceived = channel.receive() 
       println("Receiving the value $dataReceived") 
     } 
   } 
 }  
 
 println("End of program") 
} 

Sending the value 1 
Receiving the value 1 
Sending the value 2 
Receiving the value 2 
Sending the value 3 
Receiving the value 3 
End of program 

import kotlinx.coroutines.channels.Channel 
import kotlinx.coroutines.delay 
import kotlinx.coroutines.launch 
import kotlinx.coroutines.runBlocking 
 
fun main() 
{ 
 runBlocking { 
   val channel = Channel<Int>(3) 
 
   launch { 
     for (i in 1..5) 
     { ...

En résumé