Comment lire en toute sécurité les valeurs de différents Goroutines dans Go ?

La lecture des valeurs de différents threads est-elle sûre ?

Dans Go, un accès simultané sécurisé aux valeurs nécessite une synchronisation lorsque plusieurs goroutines sont impliquées, en particulier lorsque au moins l'un d'entre eux effectue des écritures. Dans le scénario donné, il est nécessaire de mettre en œuvre la synchronisation pour se prémunir contre un comportement indéfini.

Approche recommandée : utilisation de mutex

Les canaux, bien qu'ils constituent une option de transmission de messages, peuvent introduire complexité inutile en raison de la synchronisation requise pour la récupération des messages dans le thread principal. Au lieu de cela, il est recommandé d'utiliser des mutex en lecture-écriture (sync.RWMutex). Ces verrous protègent les données en appliquant l'acquisition de verrous pour les opérations de modification (travailleurs) et l'accès en lecture seule pour les récupérations de statut (thread principal).

Exemple de mise en œuvre

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()
}

Cette approche garantit que les travailleurs modifiant le nombre d'itérations acquièrent des verrous en écriture, tandis que le thread principal qui lit le nombre acquiert des verrous en lecture. locks.

Alternative : opérations atomiques

Le package sync/atomic fournit des opérations atomiques qui permettent une modification sans synchronisation de types de données spécifiques, tels que des entiers. Il garantit l'intégrité en limitant les opérations de lecture et de modification à ses fonctions atomiques.

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)
}

func (w *Worker) incIter() {
    atomic.AddInt64(&w.iter, 1)
}

Cette approche offre un mécanisme de synchronisation plus simple, mais notez qu'elle n'est applicable qu'à des types de données spécifiques.

En adoptant avec l'une de ces méthodes, vous pouvez lire en toute sécurité les valeurs des travailleurs dans différents threads, garantissant l'intégrité des données et évitant les comportements indéfinis.

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!