Coroutine en KOTLIN: launch() et async()

Pour bien comprendre les bases de la programmation asynchrone en KOTLIN, le mieux est le lien suivant: ici 

Le code ci-dessous est un exemple pour bien comprendre le comportement de join().

A insérer dans onCreate()

///////////////////////     exemple 1    /////////////////////////

runBlocking {

   // runBlocking démarre dans le Thread courant, on est maintenant

   // à l'intérieur d'un CoroutineScope, cela veut dire que nous

   // avons engendrer une variable:

   // val coroutineContext:CoroutineContext

   // pour ce context. Le runBlocking() se termine lorsque

   // tout ce qui est dedans est fait.

   println("étape 1: Démarrage à l'intérieur du runBlocking()")

   coroutineScope {

       println("étape 2: Début de coroutineScope() I")

       delay(500L)

       println("étape 3: Après le délais de 500ms dans coroutineScope() I")

       coroutineScope {

           println("étape 4: Début de coroutineScope() II")

           // Si on ajoute la ligne throw..., les deux coroutineScope()

           // et runBlocking() échouent prématurément:

           // throw CancellationException("4.")

           // Car le runBlocking transporte l'exception en dehors et létape 16 ne se réalise jamais

       }

       println("étape 5: Fin de coroutineScope() I")

   }

   val job1 = launch {

       // Ce launch se déroule en arrière plan, donc

       // l'étape 8 arrive avant l'étape 7.

       println("étape 6: Début du launch()")

       delay(2500)

       println("étape 7: Fin du launch()")

   }

   println("___ étape 8 ___")

   departAsync = System.currentTimeMillis()

   val deferr1 = async {

       // Ce async se déroule en arrière plan, mais retourne quelquechose.

       println("étape 9: Début de async")

       delay(800)

       println("étape 10: Fin de async")

       "valeur retournée par deferr1"

   }

   println("étape 11: juste après l'objet deferr1 créé par async()")

   job1.join()

   println("étape 12:  .join() oblige à attendre la fin de job1")

   println("      ..... et bloque le thread parent pour cela")

   // si on met 500ms dans job1 ecartTempsAsync est à 804ms

   // si on met 2500ms dans job1 ecartTempsAsync est à 2502ms

   val res1 = deferr1.await()

   println("étape 13 : résultat de async(): $res1")

   ecartTempsAsync = System.currentTimeMillis()-departAsync

   println("durée d'éxécution de async: $ecartTempsAsync")

   println("étape 14 : async finish")

   println("étape 15 : Fin du runBlocking()")

}

println("étape 16 :  Sortie du runBlocking()")

///////////////////////     fin exemple 1    /////////////////////////