Parlons de la coroutine de Golang

Ce qui suit est une colonne tutorielle de golang pour présenter et parler de la coroutine de golang. J'espère que cela sera utile aux amis qui en ont besoin !

Les coroutines sont des threads de couche d'application.

La couche application est la notion du système d'exploitation relative à la couche noyau, correspondant au niveau de fonctionnement du CPU. Le code principal du système d'exploitation s'exécute au niveau ring0 et le code de l'application s'exécute au niveau ring3. Les paramètres de niveau entre les couches noyau et application garantissent que certaines opérations à privilèges élevés ne peuvent être effectuées que par le code du noyau. Pour utiliser ces fonctions, les applications doivent appeler le code du noyau en appelant l'API du système d'exploitation (appelé appel système sous Linux). Cet appel fera passer le contexte du CPU de ring3 à ring0. Ce commutateur consomme du temps CPU.

Les threads sont des objets du noyau du système d'exploitation. Lors de la programmation multi-thread, s'il y a trop de threads, des changements de contexte fréquents se produiront. Ces temps CPU représentent un coût supplémentaire. Par conséquent, dans certaines programmations de serveur réseau hautement concurrentes, il n'est pas judicieux d'utiliser un seul thread pour gérer une seule connexion socket. Ainsi, le système d'exploitation fournit un modèle de programmation asynchrone basé sur le modèle d'événement. Utilisez un petit nombre de threads pour gérer un grand nombre de connexions réseau et d’opérations d’E/S. Cependant, l’utilisation de modèles de programmation asynchrones et basés sur des événements complique l’écriture du code du programme et est très sujette aux erreurs. Étant donné que les threads sont entrelacés, cela augmente également la difficulté de dépanner les erreurs.

Coroutine est un thread simulé au niveau de la couche application. Il évite le surcoût du changement de contexte et prend en compte les avantages du multi-threading. Simplifie la complexité des programmes hautement concurrents. Par exemple, dans un serveur réseau hautement concurrent, chaque socket est connectée et le serveur utilise une coroutine pour la servir. Le code est très clair. Et cela prend en compte les performances.

Alors, comment la coroutine est-elle implémentée ?

Le principe est le même que celui des threads. Lorsque le thread a passe au thread b, la progression d'exécution pertinente du thread a doit être poussée sur la pile, puis la progression d'exécution du thread b. doit être retiré de la pile. Entrez la séquence d'exécution de b. Les coroutines sont simplement appliquées pour y parvenir.

Cependant, les coroutines ne sont pas planifiées par le système d'exploitation et les applications n'ont pas la capacité ou l'autorisation d'effectuer la planification du processeur. Comment résoudre ce problème ?

La réponse est que les coroutines sont basées sur des threads. En termes d'implémentation interne, un ensemble de structures de données et n threads sont conservés. La véritable exécution est toujours constituée de threads. Le code exécuté par la coroutine est jeté dans une file d'attente pour être exécuté, et ces n threads sont retirés de la file d'attente. exécution. Cela résout le problème de l’exécution de la coroutine. Alors, comment les coroutines changent-elles ? La réponse est : golang encapsule diverses fonctions io. Ces fonctions encapsulées sont fournies aux applications et appellent en interne les fonctions io asynchrones du système d'exploitation. Lorsque ces fonctions asynchrones reviennent occupées ou bloquantes, golang profite de cette opportunité pour pousser la séquence d'exécution existante. sur la pile, permettant au thread d'extraire le code d'une autre coroutine pour l'exécution. Le principe de base est le suivant : utiliser et encapsuler les fonctions asynchrones du système d'exploitation. Y compris epoll, select de Linux et iocp, event, etc. de Windows.

Étant donné que Golang implémente des coroutines à partir de plusieurs niveaux de compilateur et de bibliothèque de base de langage, les coroutines de Golang sont l'implémentation la plus complète et la plus mature parmi les différents langages dotés de concepts de coroutine.

Cent mille coroutines peuvent fonctionner simultanément sans aucune pression. La clé est que nous n’écrivons pas de code comme celui-ci. Mais dans l’ensemble, les programmeurs peuvent se concentrer davantage sur la mise en œuvre de la logique métier et consacrer moins d’énergie à ces composants de base clés lors de l’écriture du code Golang.

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!