Comment implémenter la sécurité de la concurrence dans le langage Go ?

Avec le développement continu de la technologie informatique, nous devons passer du monothread au multi-thread pour le traitement des programmes. Comparé au modèle de traitement simultané traditionnel, le puissant mécanisme de traitement simultané du langage Go a attiré l'attention de nombreux développeurs. Le langage Go fournit un mécanisme d’implémentation léger qui facilite l’écriture de code concurrent authentique.

Cependant, il est inévitable qu'un environnement multithread entraîne de nombreuses conditions de concurrence. Lorsque plusieurs threads tentent de lire et d'écrire la même ressource partagée en même temps, des résultats inattendus peuvent survenir en raison de l'incertitude quant à l'ordre d'exécution. La condition de concurrence est l’un des problèmes potentiels que les développeurs craignent le plus.

Afin d'éviter d'éventuels problèmes de traitement simultané, le langage Go propose une riche variété de bibliothèques standards : sync. Cet article présentera le mécanisme permettant d'assurer la sécurité de la concurrence via la bibliothèque de synchronisation.

Mutex et RWMutex

mutex sont les mécanismes les plus couramment utilisés. À tout moment, une seule coroutine peut obtenir l'objet mutex, et les autres coroutines doivent attendre que la coroutine précédente libère le verrou avant de pouvoir continuer l'exécution. Mutex peut être utilisé pour protéger les ressources partagées afin que le code puisse s'exécuter de manière sûre et stable.

RWMutex est un autre type de verrouillage mutex, qui équivaut à l'extension du mutex dans le domaine de la lecture et de l'écriture. RWMutex contient deux compteurs : un compteur de lecture et un compteur d'écriture.

• Lorsque la coroutine de lecture effectue toujours une opération de lecture, l'opération d'écriture sera verrouillée et attendra la fin de l'opération de lecture.
• Lorsque la coroutine d'écriture appelle l'opération de verrouillage, toutes les opérations de lecture et d'écriture en cours de la coroutine seront verrouillées.

Ce mécanisme garantit que plusieurs coroutines peuvent effectuer des opérations de lecture en même temps, et qu'une seule coroutine peut effectuer des opérations d'écriture.

var rwMutex sync.RWMutex
var count int
func read() {
    rwMutex.RLock()
    defer rwMutex.RUnlock()

    fmt.Println(count)
}

func write() {
    rwMutex.Lock()
    defer rwMutex.Unlock()

    count++
}

Dans l'exemple de code ci-dessus, nous avons utilisé un verrou de type RWMutex pour protéger les opérations de lecture et d'écriture de la variable count. Lorsqu'un thread appelle la fonction write(), le compteur d'écriture est verrouillé et toutes les autres coroutines ne peuvent pas lire ni écrire. Lorsqu'un thread appelle la fonction read(), le compteur de lecture sera verrouillé et d'autres coroutines seront autorisées à effectuer des opérations de lecture.

WaitGroup

WaitGroup est utilisé pour attendre qu'un groupe de coroutines termine son exécution. Supposons que nous ayons n coroutines qui doivent être exécutées, alors dans la coroutine principale, nous devons appeler waitGroup.Add(n). WaitGroup.Done() est appelé une fois l'exécution de chaque coroutine terminée.

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(n int) {
            fmt.Println("goroutine ", n)
            wg.Done()
        }(i)
    }
    wg.Wait()
}

Dans cet exemple, nous utilisons WaitGroup pour attendre l'exécution de chaque goroutine, et enfin attendre que toutes les goroutines soient terminées avant de terminer le processus d'exécution principal.

Cond

Lorsque plusieurs coroutines doivent s'arrêter ou effectuer certaines opérations spécifiques, nous pouvons utiliser Cond. Il est courant d'utiliser Cond conjointement avec des verrous et WaitGroup. Il permet aux goroutines de se bloquer simultanément jusqu'à ce qu'une variable de condition change.

var cond = sync.NewCond(&sync.RWMutex{})

func printOddNumbers() {
    for i := 0; i < 10; i++ {
        cond.L.Lock()
        if i%2 == 1 {
            fmt.Println(i)
            cond.Signal()
        } else {
            cond.Wait()
        }
        cond.L.Unlock()
    }
}

func printEvenNumbers() {
    for i := 0; i < 10; i++ {
        cond.L.Lock()
        if i%2 == 0 {
            fmt.Println(i)
            cond.Signal()
        } else {
            cond.Wait()
        }
        cond.L.Unlock()
    }
}

Dans l'exemple de code ci-dessus, nous avons utilisé Cond pour garantir que les nombres pairs et impairs sont affichés séparément. Chaque coroutine utilise sync.Mutex pour verrouiller la goroutine et attendre qu'une autre coroutine accède d'abord à la variable partagée, puis surveille la valeur de la variable.

Une fois

Dans certains cas, vous devez vous assurer que certaines opérations ne sont effectuées qu'une seule fois, comme lire le fichier de configuration une seule fois ou initialiser l'état global une seule fois. Le type de langage Go sync.Once est né à cet effet. Lorsque la fonction est appelée pour la première fois, elle exécutera le code qu’elle contient et ne sera plus exécuté après les appels suivants.

var once sync.Once

func doSomething() {
    once.Do(func() {
        fmt.Println("Do something")
    })
}

Dans l'exemple ci-dessus, nous avons utilisé sync.Once pour exécuter en toute sécurité la fonction doSomething. La première fois que doSomething est appelé, la fonction ne sera exécutée qu'une seule fois en utilisant once.Do().

Conclusion

Dans cet article, nous présentons les verrous et mécanismes couramment utilisés dans le langage Go pour assurer la sécurité du code concurrent. Les types Mutex, RWMutex, WaitGroup, Cond et Once utilisant la bibliothèque de synchronisation sont tous très puissants et peuvent être utilisés pour concevoir des programmes simultanés sûrs et efficaces. Alors que les mécanismes de concurrence continuent d’évoluer, comprendre les dernières avancées en matière de programmation simultanée est essentiel pour maintenir la compétitivité de vos compétences en développement.

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!