La différence entre le fil et la coroutine dans Kotlin

Est-il un langage spécifique de la mise en œuvre de Kotlin, qui se distingue des autres langues de la mise en œuvre de coroutines?

Ce qui signifie que la coroutine est comme la lumière-poids de fil?
Quelle est la différence?
Sont kotlin coroutines effectivement en cours d'exécution en parallèle /en même temps?
Même dans le système multi-core, il y a seulement une coroutine cours d'exécution à un moment donné (est-il juste?)

Ici, je suis de départ de 100000 coroutines, ce qui se passe derrière ce code?

for(i in 0..100000){
   async(CommonPool){
    //run long running operations
  }
}

soundcloud.com/user-38099918/coroutines-with-roman-elizarov parler de Coroutines dans Kotlin

InformationsquelleAutor Jemo Mgebrishvili | 2017-03-25

kotlin kotlin-coroutines

42

Depuis que j'ai utilisé coroutines seulement sur la JVM, je vais vous parler de la JVM en arrière-plan, il y a aussi des Kotlin Natif et Kotlin JavaScript mais ces backends pour Kotlin sont hors de ma portée.

Donc, nous allons commencer avec la comparaison de Kotlin coroutines à d'autres langues coroutines. Fondamentalement, vous devez savoir qu'il existe deux types de Coroutines: stackless et stackful. Kotlin implémente stackless coroutines - cela signifie que coroutine ne dispose pas de sa propre pile, et que le fait de limiter un peu ce que coroutine peut faire. Vous pouvez lire une bonne explication ici.

Exemples:
- Stackless: C#, Scala, Kotlin
- Stackful: Quasar, Javaflow
Ce que cela signifie que la coroutine est comme la lumière-poids de fil?

Cela signifie que coroutine dans Kotlin ne dispose pas de sa propre pile, il n'a pas de carte sur un thread natif, il ne nécessite pas de changement de contexte sur un processeur.

Quelle est la différence?

Thread - préventivement multitâche. (habituellement).
Coroutine - collaboration multitâche.

Thread - géré par l'OS (généralement).
Coroutine - géré par un utilisateur.

Sont kotlin de coroutines effectivement en cours d'exécution en parallèle /en même temps?

Ça dépend, vous pouvez exécuter chaque coroutine dans son propre thread, ou vous pouvez exécuter tous les coroutines dans un thread ou un niveau fixé de pool de threads.

Plus sur la façon de coroutines exécuter ici.

Même dans un système multi-core, il y a seulement une coroutine cours d'exécution à un moment donné (est-il juste?)

Non, voir la réponse précédente.

Ici, je suis de départ de 100000 coroutines, ce qui se passe derrière ce code?

En fait, ça dépend. Mais supposons que vous écrivez le code suivant:
```
fun main(args: Array<String>) {
    for (i in 0..100000) {
        async(CommonPool) {
            delay(1000)
        }
    }
}
```
Ce code s'exécute instantanément.

Parce que nous devons attendre les résultats de async appel.

Donc, nous allons résoudre ce problème:
```
fun main(args: Array<String>) = runBlocking {
    for (i in 0..100000) {
        val job = async(CommonPool) {
            delay(1)
            println(i)
        }

        job.join()
    }
}
```
Lorsque vous exécutez ce programme kotlin permettra de créer 2 * 100000 instances de Continuation, ce qui va prendre quelques dizaines de Mo de RAM, et dans la console, vous verrez des nombres de 1 à 100000.

Donc permet de réécrire ce code de cette façon:
```
fun main(args: Array<String>) = runBlocking {

    val job = async(CommonPool) {
        for (i in 0..100000) {
            delay(1)
            println(i)
        }
    }

    job.join()
}
```
Que nous faisons maintenant? Maintenant nous allons créer seulement 100001 instances de Continuation, et c'est beaucoup mieux.

Créé suite sera distribué et exécuté sur CommonPool (qui est une instance statique de ForkJoinPool).
- Grande réponse, mais je te suggère de faire une correction importante. Les coroutines dans Kotlin utilisé pour être stackless de départ de la pré-release preview, mais ont été effectivement mises en Kotlin 1.1 avec le soutien de la suspension à une pile, de la profondeur, tout comme dans le Quasar, par exemple. Pour ceux qui sont familiers avec Quasar, il est assez facile de voir de 1 à 1 la correspondance entre le Quasar est throws SuspendExecution et Kotlin de suspend modificateur. Les détails de mise en œuvre sont très différents, bien sûr, mais l'expérience utilisateur est tout à fait similaire.
- Vous êtes également les bienvenus à la caisse de détails sur la mise en œuvre effective de Kotlin coroutines dans le document de conception.
- Afin de coroutines techniquement stackless, mais en même temps permet de suspendre à n'importe quel niveau de profondeur? N'hésitez pas à modifier ma réponse et de les corriger. Aussi, merci pour votre travail sur kotlin coroutines projet!
- Franchement, je ne sais pas ce que le terme "stackful coroutine" signifie. Je n'ai pas vu toute formelle/technique de définition de ce terme et j'ai vu différentes personnes de l'utiliser dans de tout de façon contradictoire. J'aimerais éviter d'utiliser le terme "stackful coroutine" tout simplement. Ce que je peux dire pour sûr, et ce qui est facile à vérifier, c'est que Kotlin coroutines sont plus proches de Quasar et sont vey beaucoup à la différence de C#. Mettre Kotlin corutines dans la même cellule que C# async ne semble pas droit quelle que soit votre définition du mot "stackful coroutine".
- Je voudrais classer les coroutines, dans différentes langues, de la manière suivante: C#, JS, etc ont l'avenir/la promesse à base de coroutines. Tout calcul asynchrone dans ces langues doit revenir à l'avenir, comme objet. Il n'est pas vraiment juste de les appeler stackless. Vous peut express async calculs de profondeur, c'est juste un point de vue syntaxique et la mise en œuvre-sage inefficace avec eux. Kotlin, Quasar, etc ont suspension/maintien à base de coroutines. Ils sont strictement plus puissant, car il peut être utilisé à l'avenir comme des objets ou sans eux, à l'aide de la suspension de fonctions seul.
- Ok. Voici un bon livre qui se donne à fond sur coroutines et donne plus ou moins de précision dans la définition de "stackful coroutine": inf.puc-rio.br/~roberto/docs/MCC15-04.pdf Cela implique que Kotlin implémente stackful coroutines.
InformationsquelleAutor Ruslan
47

Ce qui signifie que la coroutine est comme la lumière-poids de fil?

Coroutine, comme un fil, représente une séquence d'actions qui sont exécutées simultanément avec d'autres coroutines (threads).

Quelle est la différence?

Un thread est directement liée à la thread natif dans l'OS (système d'exploitation) et consomme une quantité considérable de ressources. En particulier, il consomme beaucoup de mémoire pour sa pile. C'est pourquoi vous ne pouvez pas créer de 100k threads. Vous êtes susceptible de manquer de mémoire. La commutation entre les threads implique noyau de système d'exploitation répartiteur et c'est une jolie opération coûteuse en termes de cycles de CPU consommé.

Une coroutine, d'autre part, est purement un utilisateur de la langue de l'abstraction. Il n'a pas d'égalité des ressources natives et, dans le cas le plus simple, utilise seulement un nombre relativement petit objet dans le segment de la JVM. C'est pourquoi il est facile de créer de 100k coroutines. La commutation entre les coroutines n'implique pas de noyau de système d'exploitation à tous. Il peut être aussi bon marché que l'invocation d'une fonction régulière.

Sont kotlin de coroutines effectivement en cours d'exécution en parallèle /en même temps?
Même dans le système multi-core, il y a seulement une coroutine cours d'exécution à un moment donné (est-il juste?)

Une coroutine peut être en cours d'exécution ou suspendu. Une suspension coroutine est pas associé à un fil, mais l'exécution d'un coroutine s'exécute sur certains thread (à l'aide d'un fil est la seule façon d'exécuter quoi que ce soit à l'intérieur d'un processus du système d'exploitation). Si les différents coroutines fonctionnent toutes sur le même thread a donc ne peut utiliser qu'un seul PROCESSEUR dans un système multicœur) ou dans différents threads (et peuvent donc les utiliser plusieurs Processeurs) est purement dans les mains d'un programmeur qui est à l'aide de coroutines.

Dans Kotlin, l'envoi de coroutines est contrôlé via coroutine contexte. Vous pouvez en savoir plus sur, puis dans le
Guide de kotlinx.coroutines

Ici, je suis de départ de 100000 coroutines, ce qui se passe derrière ce code?

En supposant que vous utilisez launch fonction et CommonPool contexte de la kotlinx.coroutines projet (qui est open source), vous pouvez examiner le code source ici:
- launch est défini ici https://github.com/Kotlin/kotlinx.coroutines/blob/master/core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/Builders.kt
- CommonPool est défini ici https://github.com/Kotlin/kotlinx.coroutines/blob/master/core/kotlinx-coroutines-core/src/main/kotlin/kotlinx/coroutines/experimental/CommonPool.kt
La launch juste crée de nouvelles coroutine, tandis que CommonPool les dépêches de coroutines à un ForkJoinPool.commonPool() qui utilise plusieurs threads et donc s'exécute sur plusieurs Processeurs dans cet exemple.

Le code qui suit launch invocation dans {...} est appelé un suspension lambda. Quelle est-elle et comment la suspension des lambdas et les fonctions mises en œuvre (compilé) ainsi que de la bibliothèque standard de fonctions et de classes comme startCoroutines, suspendCoroutine et CoroutineContext est expliqué à la correspondante Kotlin coroutines document de conception de.
- Donc grosso modo, cela signifie en commençant un couroutine est similaire à l'ajout d'un emploi dans une fil d'attente où le fil de la file d'attente est contrôlé par l'utilisateur?
- Oui. Il peut être une file d'attente pour un seul thread ou une file d'attente pour un pool de threads. Vous pouvez afficher les coroutines comme un de plus haut niveau primitif qui vous permet d'éviter manuellement (re)présentation de la continuation de vous une logique d'entreprise à la file d'attente.
- donc ne pas dire que lorsque nous avons organisé plusieurs coroutines en parallèle, ce n'est pas vrai parallélisme si le nombre de coroutines est beaucoup plus grand que le nombre de threads de threads dans la file d'attente? Si c'est le cas, alors cela semble vraiment similaire à Java Executor, il n'existe aucune relation entre ces deux?
- Ce n'est pas différent de threads. Si le nombre de threads est plus grand que le nombre de coeurs physiques de la il n'est pas vrai parallélisme. La différence est que les fils sont prévues sur les carottes préventivement, alors que les coroutines sont prévues sur les threads concert
- c'est vrai. tout est clair maintenant, merci!
InformationsquelleAutor Roman Elizarov

Vous devez vous connecter pour publier un commentaire.