Les coroutines sont d'excellentes fonctionnalités disponibles dans la langue Kotlin. Je l'ai déjà essayé et j'ai vraiment aimé.
Le but de cet article est de vous aider à comprendre les Corutines. Soyez prudent lors de la lecture et vous réussirez.
Commençons par la définition officielle de Corutin.
Les coroutines sont une nouvelle façon d'écrire du code asynchrone et non bloquant.
La première question qui se pose à la lecture de cette définition est en quoi les Coroutines sont- elles différentes des flux?
Les coroutines sont des flux légers. Un thread léger signifie qu'il n'est pas lié au thread natif, il ne nécessite donc pas de basculer le contexte vers le processeur, il est donc plus rapide.
Qu'est-ce que cela signifie, «non attaché au thread natif» ?
Les coroutines se trouvent dans de nombreux langages de programmation.
Fondamentalement, il existe deux types de Corutin:
- en utilisant la pile;
- pile de non-utilisation;
Kotlin implémente les Coroutines sans pile - cela signifie que les Coroutines n'ont pas leur propre pile, elles ne sont donc pas liées au thread natif.
Les Coroutines et les flux sont multitâches. Mais la différence est que les threads sont contrôlés par le système d'exploitation, et les Coroutines sont par les utilisateurs.
Vous pouvez maintenant lire et comprendre consciemment l'extrait du site Web officiel de Kotlin:
Les coroutines peuvent être représentées sous la forme d'un flux facilité. Comme les threads, les coroutines peuvent fonctionner en parallèle, s’attendre et communiquer. La plus grande différence est que les coroutines sont très bon marché, presque gratuites: nous pouvons les créer par milliers et payer très peu en termes de performances. Les streams sont chers. Un millier de fils peut être un problème sérieux même pour une machine moderne.
Voyons comment travailler avec Coroutines
Alors, comment démarrer coroutine (similaire au démarrage d'un thread)?
Il existe deux fonctions pour lancer des coroutines:
lancer {} vs async {} dans Kotlin Coroutines
La différence est que launch{} ne retourne rien et async{} retourne une instance Deferred qui a une fonction future.get() qui retourne le résultat d'une coroutine, tout comme Future en Java, où nous faisons future.get() pour obtenir le résultat .
Jetons un œil à l'utilisation de launch {}
fun main(args: Array<String>) { println("Kotlin Start") launch(CommonPool) { delay(2000) println("Kotlin Inside") } println("Kotlin End") }
// The output will be // Kotlin Start // Kotlin End // Kotlin Inside
Ce code lancera une nouvelle coroutine dans ce pool de threads. Dans ce cas, nous utilisons CommonPool , qui utilise ForkJoinPool.commonPool () . Les flux existent toujours dans un programme basé sur la coroutine, mais un thread peut exécuter beaucoup de coroutines, donc il n'est pas nécessaire d'avoir trop de threads.
Essayons une chose:
fun main(args: Array<String>) { delay(2000) }
Si vous le faites directement dans la fonction principale, vous recevrez un message d'erreur:
Les fonctions d'interruption ne peuvent être appelées qu'à partir de coroutine ou d'une autre fonction d'interruption.
La fonction de retard est une fonction d'interruption, nous ne pouvons donc l'appeler qu'à partir d'une coroutine ou d'une autre fonction d'interruption.
Corrigeons ceci:
fun main(args: Array<String>) { runBlocking { delay(2000) } }
Un autre exemple:
suspend fun doWorkFor1Seconds(): String { delay(1000) return "doWorkFor1Seconds" }
suspend fun doWorkFor2Seconds(): String { delay(2000) return "doWorkFor2Seconds" }
// Serial execution private fun doWorksInSeries() { launch(CommonPool) { val one = doWorkFor1Seconds() val two = doWorkFor2Seconds() println("Kotlin One : " + one) println("Kotlin Two : " + two) } }
// The output is // Kotlin One : doWorkFor1Seconds // Kotlin Two : doWorkFor2Seconds
Voyons maintenant comment utiliser async {}
// Parallel execution private fun doWorksInParallel() { val one = async(CommonPool) { doWorkFor1Seconds() } val two = async(CommonPool) { doWorkFor2Seconds() } launch(CommonPool) { val combined = one.await() + "_" + two.await() println("Kotlin Combined : " + combined) } } // The output is // Kotlin Combined : doWorkFor1Seconds_doWorkFor2Seconds
Parce que async{} nous utilisons async{} , nous pouvons appeler await() pour obtenir le résultat.
Bon apprentissage;)