paramètres de planification Golang

Golang est un langage de programmation efficace et facile à utiliser, et son mécanisme de planification est l'un des facteurs importants pour ses excellentes performances. Dans Golang, le planificateur contrôle toutes les Goroutines. Les Goroutines sont des threads légers du langage Go. Chaque Goroutine peut s'exécuter indépendamment pour atteindre une concurrence élevée. Afin de tirer pleinement parti des performances de Golang, nous devons optimiser les paramètres de planification. Cet article présentera comment configurer le mécanisme de planification de Golang.

Le planificateur de Golang est basé sur le modèle M:N Normalement, un thread du système d'exploitation (M) correspond à plusieurs Goroutines (N). Le planificateur allouera des Goroutines aux threads disponibles pour réaliser une exécution simultanée. Le planificateur planifiera les tâches en fonction de l'état de chaque Goroutine pour garantir une utilisation optimale des ressources informatiques.

Paramètres que vous devez connaître pour définir le planificateur de Golang

Avant de configurer le planificateur de Golang, vous devez connaître les paramètres suivants :

1. GOMAXPROCS

GOMAXPROCS est un paramètre utilisé pour définir le nombre maximum de processeurs pouvant être utilisés. par les programmes Golang. Par défaut, la valeur de GOMAXPROCS est le nombre de cœurs CPU de la machine. Définir ce paramètre trop grand ou trop petit affectera les performances de Golang.

Si GOMAXPROCS est trop grand, le nombre de threads augmentera, ce qui entraînera un basculement fréquent du processeur entre différents threads, entraînant une charge système accrue et affectant même l'efficacité d'exécution des applications.

Si GOMAXPROCS est défini sur une valeur trop petite, d'une part, le programme ne pourra pas utiliser pleinement les performances du processeur multicœur, d'autre part, puisque le planificateur de Golang est basé sur une planification préemptive, si GOMAXPROCS est défini ; trop petit, Goroutine ne sera pas en mesure de planifier en temps opportun, ce qui entraînera un blocage de Goroutine et une faible efficacité d'exécution du programme.

2. GOGC

GOGC est un paramètre utilisé pour contrôler l'heure et la fréquence de déclenchement du garbage collection de Golang. Le garbage collector de Golang est implémenté sur la base de l'algorithme de marquage et de balayage, ce qui signifie que le programme doit s'arrêter pendant un certain temps pendant le fonctionnement pour le garbage collection. La valeur par défaut de GOGC est 100, c'est-à-dire que lorsque l'utilisation de la mémoire tas dans le système atteint 100 % de la mémoire totale, le garbage collection sera déclenché.

Si GOGC est réglé trop bas, le système effectuera fréquemment un garbage collection, ce qui entraînera une diminution de l'efficacité de l'exécution du programme. Si GOGC est réglé trop haut, le garbage collector se déclenchera plus longtemps, ce qui affectera l'efficacité de l'utilisation de la mémoire du programme.

3. GoSchedTimeout

GoSchedTimeout est un paramètre utilisé pour définir l'intervalle de planification de Goroutine. Par défaut, la planification Goroutine est basée sur la concurrence pour les ressources informatiques, plutôt que sur la planification des tâches selon un calendrier prédéterminé.

Si GoSchedTimeout est défini sur une très petite valeur, Goroutine sera planifié fréquemment, réduisant ainsi l'efficacité d'exécution du programme. Au contraire, si GoSchedTimeout est défini sur une valeur trop grande, Goroutine ne sera pas planifié à temps, affectant ainsi l'efficacité d'exécution du programme.

4. MaxBackgroundGC

MaxBackgroundGC est un paramètre utilisé pour définir le nombre maximum de garbage collection simultanés dans Golang. Le mécanisme de récupération de place de Golang est exécuté en arrière-plan par défaut. MaxBackgroundGC est utilisé pour définir la proportion de garbage collection simultanée. La valeur par défaut de cette valeur est 1, c'est-à-dire que s'il y a actuellement 5 cœurs de processeur, un maximum d'une tâche de garbage collection peut être effectuée en parallèle en arrière-plan. en même temps.

Si MaxBackgroundGC est trop grand, cela entraînera une utilisation excessive des ressources système et affectera l'efficacité d'exécution du programme. Si MaxBackgroundGC est trop petit, cela affectera l’efficacité du garbage collection.

Définir l'optimisation du mécanisme de planification de Golang

Selon les paramètres ci-dessus, le mécanisme de planification de Golang peut être optimisé :

1. Définir GOMAXPROCS

En utilisation réelle, vous pouvez déterminer la valeur GOMAXPROCS optimale en testant différents paramètres. Ce paramètre peut être défini au démarrage du programme :

import "runtime"
func main() {
    runtime.GOMAXPROCS(8)
    //...
}

2. Set GOGC

Lorsque le programme est initialisé, vous pouvez contrôler la fréquence et le moment du garbage collection en définissant la valeur de GOGC :

import (
    "runtime"
    "time"
)
func main() {
    runtime.GC()
    //设置触发时机
    runtime.SetGCPercent(10)
    //设置触发时机和时间
    debug.SetGCPercent(20)
    debug.SetGCPercent(-1)
    //...
}

3. Set GoSchedTimeout

Golang Le planificateur est asynchrone par défaut et détermine quand Goroutine est planifié en fonction de la concurrence CPU. Par conséquent, la valeur par défaut de GoSchedTimeout est définie de manière relativement grande. Si vous devez l'ajuster, vous pouvez la définir dans le programme :

runtime.Gosched()

4. Exécutez GC régulièrement

Étant donné que le mécanisme de récupération de place de Golang est basé sur l'algorithme de balayage de marque. , pendant le garbage collection L'exécution du programme doit être suspendue, ce qui affecte l'efficacité d'exécution du programme. Par conséquent, vous pouvez éviter les effets d’une récupération de place prolongée en exécutant régulièrement le GC. Dans le programme, vous pouvez le définir comme ceci :

func gc() {
        for {
              select {
              case <-time.After(time.Minute):
                   runtime.GC()
              }
        }
}

Résumé

Golang est un langage de programmation hautes performances, et son mécanisme de concurrence est l'un des facteurs importants pour ses excellentes performances. Cet article explique comment configurer le mécanisme de planification de Golang, y compris la définition de paramètres tels que GOMAXPROCS, GOGC, GoSchedTimeout et MaxBackgroundGC. En définissant ces paramètres de manière raisonnable, les performances de Golang peuvent être pleinement utilisées et l'efficacité d'exécution du programme peut être améliorée.

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!