Quelle est la différence entre les threads Golang et les coroutines ?

La différence entre les threads golang et les coroutines : 1. Différentes méthodes de planification, les threads sont planifiés de manière préventive en fonction des tranches de temps CPU et les coroutines sont planifiées par le planificateur d'exécution du langage go ; 2. Les stratégies de planification sont différentes, les threads sont planifiés de manière préventive, la coroutine ; planification collaborative ; 3. La vitesse de changement de contexte est différente, la vitesse de changement de thread est d'environ 1 à 2 microsecondes et la vitesse de commutation de coroutine est d'environ 0,2 microsecondes 4. La taille de la pile est différente, la taille de la pile de threads est généralement de 8 Mo ; La taille de la pile de coroutines est par défaut de 2 Ko.

L'environnement d'exploitation de cet article : système Windows 10, version go1.20, ordinateur Dell g3.

La différence entre les threads Golang et les coroutines :

1 Méthode de planification

Threads : les threads sont planifiés de manière préventive en fonction des tranches de temps CPU. Le système d'exploitation effectue une commutation de contexte de thread via des signaux d'interruption (interruptions de minuterie, interruptions de périphérique d'E/S, etc.). Lorsqu'un changement de contexte de thread se produit, il doit être transféré du mode utilisateur du système d'exploitation au mode noyau et les informations d'état sont enregistrées lors du passage au thread suivant à exécuter, les informations d'état doivent être chargées et transférées depuis le mode noyau. mode noyau au mode utilisateur du système d'exploitation.

Coroutine : Coroutine existe en mode utilisateur et est planifiée par le planificateur d'exécution du langage go. Les coroutines appartiennent à un certain thread. Plusieurs coroutines peuvent être planifiées dans un seul thread. Une coroutine peut également être basculée vers plusieurs threads pour l'exécution. Par conséquent, les coroutines et les threads ont une relation plusieurs-à-plusieurs (M:N).

2. Stratégie de planification

Threads : Planification préemptive. Afin d'équilibrer le cycle d'exécution de chaque thread, le planificateur du système d'exploitation enverra périodiquement des signaux d'interruption pour forcer le changement de contexte de thread.

Coroutine : Planification collaborative. Une fois qu'une coroutine a géré ses propres tâches, elle peut transférer de manière proactive les droits d'exécution à d'autres coroutines et ne sera pas facilement préemptée. Ce n'est qu'après une exécution trop longue de la coroutine que le planificateur du langage go anticipera de force son exécution.

3. Vitesse de changement de contexte

Threads : le changement de contexte de thread nécessite de basculer entre le mode utilisateur du système d'exploitation et le mode noyau, et la vitesse de commutation est d'environ 1 à 2 microsecondes.

Coroutine : Coroutine est un thread léger en mode utilisateur. La commutation de coroutine ne nécessite pas de basculer entre le mode utilisateur et le mode noyau, et seules quelques valeurs d'état doivent être enregistrées lors de la commutation, la vitesse de commutation est donc plusieurs fois. plus rapide. C'est environ 0,2 microsecondes. (Environ 10 fois plus rapide que la vitesse de commutation des threads)

4. Taille de la pile

Threads : La taille de la pile d'un thread est généralement spécifiée lors de sa création. La taille de la pile par défaut sous Linux et Mac est généralement de 8 Mo ( peut être transmis à ulimit -s view). 2000 threads nécessitent 16 Go de mémoire virtuelle.

Coroutine : la taille par défaut de la pile de coroutines Go est de 2 Ko, et 16 Go de mémoire virtuelle peuvent créer plus de 8 millions de coroutines. En pratique, il est courant de constater l’existence de milliers de coroutines.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!