Discutez de la synchronisation et de l'exclusion mutuelle en langage Go

En tant que langage de programmation concurrent, le langage Go fournit de riches mécanismes pour prendre en charge la collaboration entre plusieurs goroutines. En programmation concurrente, la synchronisation et l'exclusion mutuelle sont deux concepts importants. Cet article explorera la synchronisation et l'exclusion mutuelle dans le langage Go et l'illustrera avec des exemples de code spécifiques.

1. Synchronisation

Dans la programmation simultanée, la synchronisation fait référence à la coordination de l'ordre d'exécution de plusieurs goroutines pour garantir qu'elles s'exécutent dans un certain ordre et éviter des problèmes tels que des conditions de concurrence. Dans le langage Go, les mécanismes de synchronisation couramment utilisés incluent Channel, WaitGroup, etc.

1. Utiliser Channel pour la synchronisation

Channel est un mécanisme important dans le langage Go utilisé pour transférer des données et se synchroniser entre les goroutines. La synchronisation entre les goroutines peut être réalisée via Channel pour assurer l'exécution séquentielle de certaines opérations.

Voici un exemple de code pour la synchronisation à l'aide de Channel :

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)
    done := make(chan bool)

    go func() {
        fmt.Println("Goroutine 1")
        ch <- 1
    }()

go func() {
        fmt.Println("Goroutine 2")
        <-ch
        done <- true
    }()

<-done
fmt.Println("Main goroutine")
}

Dans le code ci-dessus, nous créons un canal ch sans tampon et créons également un canal effectué pour la notification d'achèvement. Les deux goroutines impriment respectivement "Goroutine 1" et "Goroutine 2", puis se synchronisent via Channel ch. Enfin, le goroutine principal attend le message du canal terminé et imprime "Main goroutine" pour indiquer que l'exécution est terminée.

2. Utiliser WaitGroup pour la synchronisation

WaitGroup est un mécanisme de synchronisation fourni dans le package de synchronisation, qui peut attendre la fin d'un groupe de goroutines avant de poursuivre l'exécution.

Ce qui suit est un exemple de code pour la synchronisation à l'aide de WaitGroup :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

go func() {
        defer wg.Done()
            fmt.Println("Goroutine 1")
    }()

go func() {
        defer wg.Done()
        fmt.Println("Goroutine 2")
    }()

wg.Wait()
fmt.Println("Main goroutine")
}

Dans le code ci-dessus, nous avons créé un wg WaitGroup et ajouté 2 goroutines via la méthode Add. Une fois que chaque goroutine a terminé la tâche, elle appelle la méthode Done pour avertir le WaitGroup. Enfin, la goroutine principale appelle la méthode Wait pour attendre que toutes les goroutines terminent leur exécution.

2. Exclusion mutuelle

Lorsque plusieurs goroutines accèdent à des ressources partagées en même temps, des conditions de concurrence peuvent survenir, entraînant des conflits de données et des résultats incorrects. L'exclusion mutuelle fait référence au verrouillage des ressources partagées pour garantir qu'un seul goroutine peut accéder aux ressources partagées en même temps. Dans le langage Go, vous pouvez utiliser Mutex dans le package de synchronisation pour implémenter l'exclusion mutuelle.

Ce qui suit est un exemple de code pour utiliser Mutex pour l'exclusion mutuelle :

package main

import (
    "fmt"
    "sync"
)

var count int
var mu sync.Mutex

func increment() {
    mu.Lock()
    count++
    mu.Unlock()
}

func getCount() int {
    mu.Lock()
    defer mu.Unlock()
    return count
}

func main() {
    for i := 0; i < 10; i++ {
    go increment()
    }

fmt.Println("Final count:", getCount())
}

Dans le code ci-dessus, nous définissons un nombre de variables globales et un Mutex mu. La fonction d'incrémentation utilise Mutex pour garantir la sécurité de la concurrence lors de l'incrémentation du nombre. La goroutine principale crée 10 goroutines pour effectuer des opérations d'incrémentation simultanément, et obtient finalement la valeur de comptage finale via la fonction getCount et l'imprime.

En résumé, cet article explore la synchronisation et l'exclusion mutuelle dans le langage Go et fournit des exemples de code spécifiques pour illustrer. Grâce à des mécanismes de synchronisation et d'exclusion mutuelle appropriés, la collaboration entre les goroutines peut être gérée efficacement pour garantir l'exactitude et les performances du programme. Dans la programmation concurrente réelle, il est nécessaire de choisir des méthodes de synchronisation et d'exclusion mutuelle appropriées en fonction de scénarios spécifiques pour améliorer la fiabilité et l'efficacité du programme.

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!