Lesquelles des coroutines (goroutines et corotines de kotlin) sont les plus rapides?
Les corutines Kotlin sont du sucre pour la machine à états finis et certains exécuteurs de tâches (par exemple, ForkJoinPool par défaut). https://github.com/Kotlin/kotlin-coroutines/blob/master/kotlin-coroutines-informal.md#implementation-details
En d'autres termes, il n'y a pas encore de coroutines d'exécution dans l'exécution Java/kotlin (mais cela peut changer avec http://cr.openjdk.Java.net/~rpressler/loom/Loom-Proposal.html ). Kotlin coroutine est juste séquentiel des tâches, qui sont exécutées une par une. Chaque tâche peut être exécutée dans n'importe quel thread du pool de threads.
Le runtime Go prend en charge les "coroutines". Mais les goroutines ne sont pas les vraies coroutines. Goroutines ne permet pas de fixer des limites de rendement dans le programme. En outre, Go ne permet pas de définir un pool de threads personnalisé. Vous pouvez définir uniquement la taille des threads dans le pool par défaut.
La première différence entre les coroutines kotlin et les goroutines est que Go runtime gère la coroutine en cours d'exécution à ce moment. Lorsque la goroutine est bloquée à certaines opérations IO (ou primitives de synchronisation), passez aux choix Job suivant pour l'exécuter. Dans JVM, il n'y a pas de changement de travail intellectuel en ces termes.
Pour cette raison, Go peut modifier à moindre coût le travail en cours d'exécution. Go n'a qu'à modifier quelques registres https://groups.google.com/forum/#!msg/golang-nuts/j51G7ieoKh4/wxNaKkFEfvcJ . Mais certaines personnes disent que la JVM peut utiliser une pile de threads au lieu d'utiliser des registres. Il n'y a donc pas du tout de sauvegarde et de chargement des registres.
La deuxième différence entre les coroutines kotlin et les goroutines est le type de coroutines. Les coroutines Kotlin sont des coroutines sans pile. Les goroutines sont des coroutines empilées. Tous les états des coroutines Kotlin sont stockés dans le contexte Kotlin, qui est stocké en tas. L'état des goroutines est stocké dans les registres et la pile de threads.
Je veux savoir quelles coroutines (goroutines et kotlin coroutines) sont plus rapides dans IO tâches liées? Tâches liées au processeur? Qu'en est-il de la consommation de mémoire?
Les coroutines dans Kotlin sont implémentées d'une manière différente des goroutines dans Go, donc celle qui est "plus rapide" dépend du problème que vous résolvez et du type de code que vous écrivez.
En général, il est très difficile de dire à l'avance lequel fonctionnera mieux pour un problème que vous avez sous la main. Vous devez exécuter des tests de performance pour vos charges de travail particulières pour le comprendre. Cependant, voici un résumé général des principales différences qui devraient vous donner quelques conseils.
Les coroutines Kotlin nécessitent moins de mémoire par instance simple que les goroutines Go. Une simple coroutine dans Kotlin n'occupe que quelques dizaines d'octets de mémoire de tas, tandis qu'une goroutine Go commence avec 4 Ko d'espace de pile. Cela signifie que si vous prévoyez d'avoir littéralement des millions de coroutines, les coroutines de Kotlin pourraient vous donner un avantage contre Go. Cela rend également les coroutines Kotlin mieux adaptées aux tâches très courtes et de courte durée comme les générateurs et les séquences paresseuses.
Les coroutines Kotlin peuvent aller à n'importe quelle profondeur de pile, mais chaque invocation de la fonction de suspension alloue un objet en tas pour sa pile. Une pile d'invocation dans les coroutines Kotlin est actuellement implémentée en tant que liste chaînée d'objets de tas. En revanche, les goroutines de Go utilisent un espace de pile linéaire. Cela rend la suspension sur des piles profondes plus efficace dans Go. Donc, si le code que vous écrivez suspend très profondément dans la pile, vous trouverez peut-être que les goroutines sont plus efficaces pour vous.
L'efficacité asynchrone IO est un problème de conception très multidimensionnel. Une approche efficace pour un type d'application peut ne pas donner les meilleures performances à une autre. Toutes les opérations IO dans les coroutines Kotlin sont implémentées par des bibliothèques écrites en Kotlin ou Java. Il existe une grande variété de bibliothèques IO disponibles pour le code Kotlin. Dans Go asynchrone IO est implémenté par le moteur d'exécution Go à l'aide de primitives qui ne sont pas disponibles pour le code Go général. Si l'approche Go pour implémenter les opérations IO est bien adaptée à votre application, vous constaterez peut-être que son intégration étroite avec le moteur d'exécution Go vous offre un avantage. De l'autre côté, dans Kotlin, vous pouvez trouver une bibliothèque ou en écrire une vous-même qui implémente asynchrone IO de la manière la mieux adaptée à votre application.
Le runtime Go prend le contrôle total de la planification de l'exécution des goroutines sur les threads physiques du système d'exploitation. L'avantage de cette approche est que vous n'avez pas à y penser. Avec les coroutines Kotlin, vous avez un contrôle précis sur l'environnement d'exécution de vos coroutines. Ceci est sujet aux erreurs (par exemple, vous pouvez simplement créer trop de pools de threads différents et perdre votre temps CPU sur le changement de contexte entre eux). Cependant, il vous donne la possibilité d'affiner votre allocation de threads et vos commutateurs de contexte pour votre application. Par exemple, dans Kotlin, il est facile d'exécuter l'ensemble de votre application ou un sous-ensemble de son code dans un seul thread OS (ou pool de threads) pour éviter complètement de changer de contexte entre les threads OS simplement en écrivant un code approprié pour cela.