Go Language Guide pratique de programmation multithread

Guide pratique de la programmation multithread dans le langage Go

En tant que langage de programmation moderne, le langage Go est doté d'un excellent support de concurrence, ce qui rend la programmation multithread très simple et efficace. Cet article présentera comment utiliser le langage Go pour la programmation multithread et démontrera diverses techniques et bonnes pratiques à travers des exemples de code spécifiques.

1. Modèle de concurrence du langage Go

Dans le langage Go, la goroutine est l'unité de base de la concurrence. Il est plus léger que les threads traditionnels et peut créer des milliers de goroutines dans un seul thread sans entraîner de gaspillage de ressources. La création de goroutine est très simple. Il vous suffit d'ajouter le mot-clé "go" avant l'appel de la fonction, comme indiqué ci-dessous :

func main() {
    go myFunction()
}

func myFunction() {
    // do something
}

De cette façon, vous pouvez créer une goroutine dans la fonction principale pour exécuter la fonction myFunction, et la fonction principale La fonction continue d'exécuter sa propre logique.

2. Synchronisation et communication

Dans la programmation multithread, la synchronisation et la communication sont des concepts très importants. Le langage Go fournit des canaux pour mettre en œuvre la communication entre différentes goroutines. Un canal est un type de référence et doit être créé à l'aide de make. La syntaxe est la suivante :

c := make(chan int)

Le transfert de données entre goroutines peut être réalisé via des canaux, par exemple :

func main() {
    c := make(chan int)
    go sendValue(c)
    value := <-c
    fmt.Println(value)
}

func sendValue(c chan int) {
    c <- 10
}

Dans ce code, la fonction principale crée un canal et La fonction sendValue est appelée dans une goroutine pour envoyer une valeur entière au canal, puis la valeur est reçue et imprimée dans la fonction principale.

3. Utilisez le package de synchronisation pour la synchronisation

En plus des canaux, le langage Go fournit également le package de synchronisation pour les opérations de synchronisation, notamment les verrous mutex et les verrous en lecture-écriture. Les verrous Mutex sont utilisés pour protéger les ressources partagées et peuvent être implémentés via sync.Mutex. Les verrous en lecture-écriture sont utilisés pour améliorer les performances dans des scénarios avec plus de lectures et moins d'écritures, et peuvent être implémentés via sync.RWMutex.

var (
    data map[string]string
    mutex sync.Mutex
)

func setValue(key, value string) {
    mutex.Lock()
    data[key] = value
    mutex.Unlock()
}

func getValue(key string) string {
    mutex.Lock()
    defer mutex.Unlock()
    return data[key]
}

Dans ce code, un mutex est utilisé pour protéger une ressource partagée de type carte afin de garantir la sécurité des threads lors de l'écriture et de la lecture des données.

4. Mode de concurrence

Dans la programmation multithread réelle, il existe certains modes de concurrence courants, tels que le mode producteur-consommateur, le mode pool de travailleurs, etc. Nous prenons ici le modèle producteur-consommateur comme exemple pour présenter comment l'implémenter dans le langage Go.

func producer(c chan int) {
    for i := 0; i < 10; i++ {
        c <- i
    }
    close(c)
}

func consumer(c chan int) {
    for {
        value, ok := <-c
        if !ok {
            break
        }
        fmt.Println(value)
    }
}

func main() {
    c := make(chan int)
    go producer(c)
    go consumer(c)
    time.Sleep(time.Second)
}

Dans ce code, la fonction producteur envoie les nombres 0 à 9 au canal, puis ferme le canal. La fonction consommateur reçoit la valeur du canal et l'imprime. La fonction principale crée un canal et démarre le producteur. et consommateur respectivement.

Ce qui précède est un guide pratique pour la programmation multithread en langage Go. En comprenant le modèle de concurrence, la synchronisation et la communication du langage Go, en utilisant le package de synchronisation pour la synchronisation et les modes de concurrence courants, vous pouvez mieux utiliser les puissantes capacités de concurrence de Passez au langage et obtenez une programmation multithread efficace. J'espère que le contenu de cet article pourra aider les lecteurs à mieux comprendre et appliquer la pratique de la programmation multithread dans le langage Go.

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!