Stratégies de planification pour les fonctions Golang et Goroutine

Dans Go, les fonctions sont exécutées dans l'ordre de création (FIFO) et la planification Goroutine est affectée par le nombre de cœurs de processeur, la priorité et les politiques du système d'exploitation. Des cas pratiques montrent que Go planifiera les Goroutines sur les cœurs de processeur disponibles en parallèle pour réaliser un calcul parallèle.

Stratégie de planification des fonctions et des Goroutines dans Go

En Go, l'exécution des fonctions et les stratégies de planification des Goroutines sont cruciales pour les performances de l'application. Cet article présentera les principes de base des stratégies de planification dans Go et fournira un cas pratique pour démontrer le comportement de planification. Le programme

Function Scheduling

Go se compose d'un ensemble de fonctions exécutées simultanément. Chaque fonction est appelée une Goroutine. Go planifie automatiquement les Goroutines sur différents cœurs de processeur pour réaliser un calcul parallèle.

L'exécution des fonctions suit le principe First In First Out (FIFO), c'est-à-dire que les Goroutines seront exécutées dans l'ordre dans lequel elles sont créées. Cependant, lorsqu'un Goroutine bloque (par exemple en attendant une opération d'E/S), d'autres Goroutines peuvent continuer à s'exécuter.

Planification Goroutine

La planification Goroutine est contrôlée par :

• Nombre de cœurs de processeur disponibles : Go essaiera de distribuer uniformément les Goroutines à tous les cœurs de processeur disponibles.
• Priorité Goroutine : Chaque Goroutine a une priorité avec des valeurs allant de -16 à +15. Les Goroutines avec une priorité plus élevée seront exécutées avant les Goroutines avec une priorité inférieure.
• Stratégie de planification du système d'exploitation : La stratégie de planification de Go peut être affectée par la stratégie de planification du système d'exploitation sous-jacent.

Cas pratique

Ce qui suit est un programme Go simple qui démontre la planification des fonctions et le comportement de planification de Goroutine :

package main

import (
    "fmt"
    "runtime"
)

func worker(i int) {
    fmt.Printf("Worker %d running on processor %d\n", i, runtime.GOMAXPROCS(-1))
    for {
        // 模拟工作
    }
}

func main() {
    // 创建 4 个 Goroutine
    for i := 0; i < 4; i++ {
        go worker(i)
    }

    // 等待 Goroutine 完成
    var input string
    fmt.Scanln(&input)
}

Sortie :

Worker 0 running on processor 1
Worker 1 running on processor 1
Worker 2 running on processor 2
Worker 3 running on processor 2

Dans cet exemple, quatre Goroutines sont planifiées en parallèle sur deux cœurs de processeur disponibles. Cela indique que Go distribuera automatiquement les Goroutines à plusieurs processeurs pour réaliser un calcul parallèle.

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!