Pourquoi les valeurs des variables de mon programme Go sont-elles désynchronisées sur différents threads ?

En langage Go, l'utilisation de coroutines pour implémenter des opérations simultanées est devenue un moyen très populaire. Cependant, lorsque les variables sont partagées entre plusieurs coroutines, des problèmes de course aux données peuvent facilement survenir. Une course aux données est un bug de programmation simultané qui se produit lorsque deux ou plusieurs threads tentent de lire ou d'écrire le même emplacement mémoire en même temps. Dans ce cas, le programme peut produire des résultats imprévisibles et erronés.

En langage Go, afin d'éviter cette situation, vous pouvez utiliser des mécanismes tels que les verrous mutex pour la résoudre.

Utilisation du verrouillage mutex

Le verrouillage mutex est une sorte de verrou en langage Go utilisé pour l'accès synchrone aux ressources partagées. Lorsqu'une coroutine doit accéder à une ressource partagée, elle doit d'abord obtenir un mutex, puis effectuer l'opération. Une fois l'opération terminée, le verrou mutex doit être libéré afin que d'autres coroutines puissent continuer à accéder aux ressources partagées.

Le verrou mutex est utilisé comme suit :

import "sync"

var mu sync.Mutex // 互斥锁

func main() {
    // ...

    mu.Lock() // 获取互斥锁
    // 访问共享资源
    mu.Unlock() // 释放互斥锁

    // ...
}

Dans le code ci-dessus, la méthode Lock() est utilisée pour obtenir le verrou mutex, et la méthode Unlock() est utilisée. Libérez le verrou mutex. Lorsqu'une coroutine acquiert un verrou mutex, les autres coroutines doivent attendre qu'elle libère le verrou mutex avant de pouvoir acquérir le verrou mutex. Cela évite les problèmes de course aux données. Lock()方法用于获取互斥锁，Unlock()方法用于释放互斥锁。当一个协程获取到互斥锁后，其他协程必须等待它释放互斥锁之后，才能获取到互斥锁。这样就可以避免数据竞争的问题。

例子

下面是一个例子，演示了如何使用互斥锁来解决数据竞争的问题。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    count := 0
    mu := sync.Mutex{}

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            count++
            mu.Unlock()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println("count: ", count)
}

在上面的代码中，我们首先定义了一个WaitGroup对象，用于记录协程的数量。然后定义一个互斥锁mu和一个计数器count。接着启动100个协程，每个协程对计数器进行加一的操作。由于计数器count是共享资源，所以需要在操作前获取互斥锁，在操作完成后释放互斥锁。最后使用Wait()

Exemple

Ce qui suit est un exemple qui montre comment utiliser un verrou mutex pour résoudre le problème de la course aux données.

count:  100

Dans le code ci-dessus, nous définissons d'abord un objet WaitGroup pour enregistrer le nombre de coroutines. Définissez ensuite un mutex mu et un compteur count. Démarrez ensuite 100 coroutines, et chaque coroutine incrémente le compteur de un. Puisque le compteur count est une ressource partagée, il est nécessaire d'obtenir le verrou mutex avant l'opération et de libérer le verrou mutex une fois l'opération terminée. Enfin, utilisez la méthode Wait() pour attendre la fin de toutes les coroutines et imprimer la valeur du compteur.

Les résultats de l'opération sont les suivants :

rrreee

A en juger par les résultats, l'opération a été un succès. À ce stade, les valeurs des variables sont synchronisées dans différents threads. 🎜🎜Résumé🎜🎜Lors de l'utilisation de coroutines pour des opérations simultanées dans le langage Go, plusieurs coroutines peuvent accéder à la même ressource partagée, vous devez donc faire attention à la question de la concurrence entre les données. Le verrouillage Mutex est une sorte de verrou utilisé pour résoudre la concurrence en matière de données, ce qui peut efficacement éviter le problème de plusieurs coroutines accédant à la même ressource partagée en même temps. En utilisant des verrous mutex, il est possible de garantir que les valeurs des variables seront synchronisées dans différents threads. 🎜

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!