Analyse approfondie des fonctionnalités du langage Golang : programmation multithread et planification des tâches-Golang-php.cn

Analyse approfondie des fonctionnalités du langage Golang : programmation multithread et planification des tâches

王林

Libérer： 2023-07-18 14:33:24

original

1574 Les gens l'ont consulté

Analyse approfondie des fonctionnalités du langage Golang : programmation multithread et planification des tâches

Introduction :
Golang (également connu sous le nom de langage Go), en tant que langage statiquement fortement typé, est progressivement apprécié des développeurs pour ses excellentes performances et sa syntaxe concise. . L'un de ses objectifs de conception est de prendre en charge la programmation multithread. Grâce aux fonctionnalités de Goroutine et Channel, les développeurs peuvent facilement implémenter une programmation multithread. Cet article explorera en profondeur les fonctionnalités de programmation multithread de Golang, en se concentrant sur la relation entre la planification des tâches et les coroutines.

Programmation multithread et coroutines :
Dans Golang, l'unité de concurrence la plus basique est la coroutine (Goroutine), qui peut être comprise comme un thread léger. Par rapport aux threads traditionnels, la surcharge de création et de destruction des coroutines est extrêmement faible et le changement de contexte peut être effectué efficacement. Par conséquent, dans Golang, nous pouvons créer un grand nombre de coroutines pour exécuter des tâches simultanément sans nous soucier des problèmes de performances.

Voici un exemple de code simple qui montre comment créer et démarrer une coroutine :

package main

import (
    "fmt"
    "time"
)

func main() {
    go hello()
    time.Sleep(1 * time.Second)
    fmt.Println("main goroutine exit")
}

func hello() {
    fmt.Println("Hello, Golang!")
}

Copier après la connexion

Dans l'exemple ci-dessus, nous avons créé une coroutine via le mot-clé go et avons passé main démarre cette coroutine. Dans la fonction main, nous attendons 1 seconde via la fonction time.Sleep pour nous assurer que la coroutine peut fonctionner normalement. Enfin, nous générons un message et attendons la fin de la coroutine avant la fin de la fonction main. En exécutant le programme, vous pouvez obtenir le résultat suivant : go关键字创建了一个协程，并通过main函数启动了这个协程。在main函数中，我们通过time.Sleep函数等待1秒，以确保协程能够正常运行。最后，我们输出一条消息，并在main函数结束前等待协程的结束。运行该程序，可以得到以下输出：

Hello, Golang!
main goroutine exit

Copier après la connexion

可以看到，协程的创建和启动非常简单，只需使用go

package main

import (
    "fmt"
    "time"
)

func main() {
    for i := 0; i < 5; i++ {
        go worker(i)
    }

    time.Sleep(3 * time.Second)
    fmt.Println("main goroutine exit")
}

func worker(id int) {
    fmt.Printf("Worker %d started
", id)
    time.Sleep(1 * time.Second)
    fmt.Printf("Worker %d finished
", id)
}

Copier après la connexion

Comme vous pouvez le voir, la création et le démarrage de la coroutine sont très simples, utilisez simplement le mot-clé go. Le code de la coroutine s'exécutera de manière asynchrone et ne bloquera pas l'exécution du thread principal.

La relation entre la planification des tâches et les coroutines :

Le planificateur de Golang (Scheduler) est chargé de coordonner l'exécution entre les coroutines. Le planificateur attribue la coroutine au thread du système (Thread) pour implémenter la planification et l'exécution de la coroutine sur le thread physique. Le planificateur de Golang fait partie du système d'exécution (Runtime). Il est responsable de la planification de l'exécution des tâches lors de l'exécution des coroutines et implémente des tâches telles que la gestion des priorités, le changement de contexte et le blocage/réveil.

Dans Golang, le planificateur adopte une stratégie de gestion de threads appelée modèle GMP. G signifie Global, P signifie Thread physique et M signifie Machine. L'idée principale du modèle GMP est de lier une coroutine (Goroutine) à un thread physique (Thread) et d'attribuer dynamiquement des tâches d'exécution de coroutine sur différents threads via le planificateur (Scheduler).

Le planificateur de Golang adopte une stratégie de planification préemptive, c'est-à-dire que lorsqu'une coroutine prend trop de temps à s'exécuter ou est bloquée, le planificateur planifiera activement l'exécution d'autres coroutines pour améliorer les performances de concurrence du programme. Le planificateur ajustera également dynamiquement l'ordre d'exécution des tâches en fonction de la priorité et du type de tâche de la coroutine pour garantir la performance globale du programme.

Ce qui suit est un exemple de code qui montre la relation de planification entre plusieurs coroutines :

Worker 0 started
Worker 1 started
Worker 2 started
Worker 3 started
Worker 4 started
Worker 4 finished
Worker 0 finished
Worker 1 finished
Worker 2 finished
Worker 3 finished
main goroutine exit

Copier après la connexion

Dans l'exemple ci-dessus, nous avons créé 5 coroutines pour exécuter des tâches simultanément. Chaque coroutine affichera son propre identifiant et des simulations de sommeil seront effectuées avant et après l'exécution de la tâche. Nous attendons 3 secondes dans le thread principal pour nous assurer que toutes les coroutines peuvent être exécutées. En exécutant ce programme, vous pouvez obtenir le résultat suivant :

rrreee

Vous pouvez voir que l'ordre d'exécution entre plusieurs coroutines est incertain et que l'ordre de sortie peut être différent à chaque exécution. En effet, le planificateur planifie dynamiquement l'exécution de la coroutine sur différents threads pour améliorer les performances de concurrence. De plus, l'ordre d'exécution des coroutines est également affecté par des facteurs tels que le système d'exploitation et l'environnement matériel.

Conclusion :

Grâce à une analyse approfondie des fonctionnalités de programmation multithread et de planification de tâches de Golang, nous pouvons constater que Golang fournit un modèle de programmation simultanée simple et efficace. Grâce aux caractéristiques des coroutines et des canaux, nous pouvons facilement mettre en œuvre l'allocation et la planification de tâches simultanées et tirer pleinement parti des avantages en termes de performances des processeurs multicœurs. Dans les projets réels, nous pouvons utiliser de manière flexible les coroutines et les canaux en fonction de tâches et de besoins spécifiques pour obtenir une programmation simultanée de haute qualité.

Références :