Comment implémenter la multitâche en Kotlin?

La multitâche en Kotlin peut être réalisée de plusieurs manières :

1. Fils Java standard (Threads) :

   // Implémenter l'interface Runnable
   class MyRunnable : Runnable {
       override fun run() {
           // Code qui sera exécuté dans un thread séparé
           println("Bonjour depuis le thread : ${Thread.currentThread().name}")
       }
   }
   
   fun main() {
       // Créer une instance de Runnable
       val runnable = MyRunnable()
       // Créer un objet Thread avec Runnable
       val thread = Thread(runnable)
       // Démarrer le thread
       thread.start()
   }
   

   Ou avec une expression lambda :

   fun main() {
       val thread = Thread {
           // Code qui sera exécuté dans un thread séparé
           println("Bonjour depuis le thread : ${Thread.currentThread().name}")
       }
       thread.start()
   }
   

2. Coroutines Kotlin : C'est une approche recommandée et plus moderne en Kotlin, offrant une multitâche légère.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       // Créer une nouvelle coroutine dans le scope global
       launch {
           delay(1000L) // Retard non bloquant de 1 seconde
           println("Bonjour depuis la coroutine")
       }
       // Le thread principal continue de fonctionner
       println("Bonjour depuis le thread principal")
       // runBlocking attend la fin de toutes les coroutines enfants
   }
   

   Exemples d'utilisation de différents constructeurs de coroutines :

   • launch : Lance une nouvelle coroutine sans valeur de retour.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       launch {
           println("Cette coroutine effectue simplement une action")
       }
   }
   

   • async : Lance une nouvelle coroutine qui retourne un résultat via Deferred.

   import kotlinx.coroutines.*
   
   fun main() = runBlocking {
       val deferredResult = async {
           delay(1000L)
           "Résultat de la coroutine"
       }
       val result = deferredResult.await() // Attendre le résultat
       println(result)
   }
   

3. RxKotlin/RxJava : La programmation réactive permet également de travailler avec des opérations asynchrones et multitâches, en utilisant des planificateurs (Schedulers).

   import io.reactivex.rxjava3.core.Observable
   import io.reactivex.rxjava3.schedulers.Schedulers
   
   fun main() {
       Observable.just("Élément asynchrone")
           .subscribeOn(Schedulers.io()) // S'abonner sur le thread I/O
           .observeOn(Schedulers.computation()) // Observer les résultats sur le thread de calcul
           .subscribe { item ->
               println("Reçu : $item sur le thread ${Thread.currentThread().name}")
           }
   
       Thread.sleep(2000) // Attendre la fin des opérations asynchrones
   }
   

Le choix de la méthode dépend de la tâche spécifique. Pour la plupart des applications modernes en Kotlin, les coroutines sont préférées pour leur légèreté, leur facilité d'utilisation et leur support intégré dans le langage. Les threads Java peuvent être appropriés pour un contrôle de bas niveau, et les bibliothèques réactives pour travailler avec des flux de données.