Comment puis-je lire en toute sécurité les valeurs de plusieurs Goroutines dans Go ?

Lire les valeurs en toute sécurité à partir de différents threads dans Go

Dans Go, l'accès simultané aux valeurs de plusieurs goroutines sans synchronisation appropriée est dangereux. Pour garantir l'intégrité des données, il est crucial d'utiliser des mécanismes de synchronisation.

Synchronisation avec mutex et verrous en lecture/écriture

Dans le scénario donné, où le thread principal doit collecter valeurs des threads de travail toutes les 10 secondes, les canaux ne suffiront pas. Au lieu de cela, un mutex en lecture/écriture peut être utilisé.

Les travailleurs obtiendront un verrou en écriture lors de la mise à jour de leurs valeurs, tandis que le thread principal acquerra un verrou en lecture lors de la récupération des valeurs. Cela évite les conditions de concurrence critique et garantit la cohérence des données.

Exemple d'implémentation avec Mutex

Le code suivant illustre une implémentation simple utilisant un mutex :

type Worker struct {
    iterMu sync.RWMutex
    iter   int
}

func (w *Worker) Iter() int {
    w.iterMu.RLock()
    defer w.iterMu.RUnlock()
    return w.iter
}

func (w *Worker) setIter(n int) {
    w.iterMu.Lock()
    w.iter = n
    w.iterMu.Unlock()
}

Alternative : utiliser des compteurs atomiques

Alternativement, le Le package sync/atomic fournit des compteurs atomiques thread-safe, permettant des opérations de lecture et d'écriture directes sans la surcharge des mutex.

type Worker struct {
    iter int64
}

func (w *Worker) Iter() int64 {
    return atomic.LoadInt64(&w.iter)
}

func (w *Worker) setIter(n int64) {
    atomic.StoreInt64(&w.iter, n)
}

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!