Explication détaillée du planificateur de coroutines en langage Go

Le langage Go est livré avec un planificateur de coroutines efficace, qui peut facilement gérer des tâches simultanées et mettre en œuvre des programmes hautes performances. Dans cet article, nous examinerons en profondeur le planificateur de coroutines dans le langage Go et explorerons sa mise en œuvre, son fonctionnement et son optimisation.

Introduction aux coroutines

Les coroutines sont des threads légers ou des threads en mode utilisateur. Il est planifié par le programmeur et non par le système d'exploitation. La caractéristique des coroutines est qu'elles sont non préemptives, c'est-à-dire que le contexte n'est changé que lorsque la fonction rendement() est explicitement appelée. Par conséquent, la surcharge de commutation des coroutines est très faible, elles peuvent être facilement créées et détruites, et de nombreuses coroutines peuvent être exécutées en même temps pour réaliser une exécution simultanée de programmes.

Modèle de coroutine du langage Go

Le langage Go adopte le modèle de coroutine M:N, c'est-à-dire plusieurs threads en mode utilisateur M, correspondant à la relation de plusieurs threads au niveau du système N. Ce modèle tire pleinement parti des processeurs multicœurs, tout en réduisant la surcharge de changement de contexte et en améliorant les performances de planification.

M représente le thread du système d'exploitation, c'est-à-dire le thread physique, qui est la plus petite unité de planification du système d'exploitation. N représente le thread virtuel (goroutine) dans le système d'exécution du langage Go (runtime), qui est la plus petite unité permettant d'atteindre la concurrence. N goroutines seront mappées sur M threads et planifiées par le planificateur au moment de l'exécution.

Coroutine Scheduler

Le planificateur de coroutines est le composant principal du système d'exécution du langage Go, responsable de la gestion et de la planification de plusieurs coroutines pour exécuter des tâches. Il s'agit d'un planificateur de haut niveau qui peut contrôler l'exécution et la commutation des coroutines et réaliser une planification de niveau des coroutines. Dans le langage Go, le planificateur de coroutine utilise une entité d'exécution supplémentaire appelée Goroutine, qui peut changer plus efficacement les tâches d'exécution dans la coroutine.

Principe de mise en œuvre du planificateur de coroutine

Le principe de mise en œuvre du planificateur de coroutine peut être divisé en deux niveaux : le niveau du système d'exploitation et le niveau du système d'exécution du langage Go.

Niveau du système d'exploitation

Au niveau du système d'exploitation, le planificateur de coroutines mappera plusieurs threads utilisateur à plusieurs threads du système d'exploitation au moment de l'exécution, en tirant parti des capacités de calcul parallèle des processeurs multicœurs.

L'architecture M:N dans le modèle de coroutine du langage Go, c'est-à-dire que M représente le thread du système d'exploitation (Machine), N représente le thread virtuel du langage Go (N, représente Goroutine) et le planificateur gère la planification à exécution. La fonction principale du planificateur est de maintenir une file d'attente de tâches de planification sur chaque thread du système d'exploitation, de planifier dynamiquement l'exécution des tâches sur chaque thread en fonction de la priorité des tâches dans la file d'attente des tâches et de l'algorithme de planification, et de gérer les ressources des threads.

Niveau du système d'exécution du langage Go

Au niveau du système d'exécution du langage Go, le planificateur de coroutine utilise trois mécanismes : le planificateur, la file d'attente du planificateur et P.

Scheduler

Le planificateur de coroutines du langage Go est contrôlé par un planificateur global, qui gère la file d'attente du planificateur, la file d'attente P, le numéro de rotation, l'algorithme de planification, etc. Le planificateur gère dynamiquement l'exécution des tâches sur chaque thread pour optimiser l'efficacité d'exécution de la coroutine.

File d'attente du planificateur

La file d'attente du planificateur est l'endroit où le planificateur enregistre toutes les Goroutines en attente d'être planifiées. Lorsque le planificateur alloue Goroutine à P, il recherchera d'abord les Goroutines en attente de planification dans la file d'attente. S'il les trouve, il les placera immédiatement dans la file d'attente locale de P. S'il ne les trouve pas, il créera un nouveau Goroutine et le placera dans ceux de P. file d'attente locale.

P

P est un processeur utilisé pour exécuter Goroutine, et la file d'attente qu'il possède est la file d'attente locale. Le nombre de P est contrôlé par la variable d'environnement GOMAXPROCS. S'il n'est pas défini, le programme Go utilise par défaut le nombre de cœurs de la machine.

Optimisation du planificateur Go

Le planificateur Go a de nombreuses stratégies d'optimisation, en voici quelques-unes :

1. Vol de travail

Lorsque toutes les Goroutines d'une certaine file d'attente P sont bloquées, le planificateur Go recherchera des Goroutines dans d'autres Les files d'attente P en volent ensuite et les mettent dans leurs propres files d'attente pour les exécuter. Cette stratégie garantit une charge stable et un partage de charge pour tous les P.

2. Préemption

Goroutine peut se définir une minuterie pendant l'exécution. Lorsque le temps est écoulé, appelez runtime.Goexit pour indiquer au runtime que cette Goroutine peut être activement planifiée. Le planificateur Go a également une politique de préemption si la goroutine n'appelle pas activement Goexit. Avant Go 1.13, la préemption n'était possible que lorsque GOMAXPROCS était égal à 1. Il a maintenant été mis à niveau pour prendre en charge davantage de situations.

3. Local Runqueue

Afin de réduire la concurrence pour les tâches entre les différents threads, chaque thread aura sa propre file d'attente locale en premier et ne les exécutera que lorsque la file d'attente locale est vide. Accédez à la file d'attente globale pour obtenir la tâche.

Résumé

Le planificateur de coroutines est l'un des composants clés de la concurrence hautes performances dans le langage Go. Il est responsable de la gestion et de la planification de plusieurs coroutines pour exécuter des tâches. Il adopte le modèle de coroutine M:N et utilise différents mécanismes et algorithmes au niveau du système d'exploitation et au niveau du système d'exécution du langage Go pour garantir une exécution et une planification efficaces des coroutines. Dans le même temps, le planificateur Go dispose également de nombreuses stratégies d'optimisation, telles que la préemption des coroutines, les files d'attente d'exécution locales et le vol de tâches, qui peuvent aider le programme à s'exécuter plus efficacement et à améliorer ses performances et son débit.

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!