Comment puis-je collecter en toute sécurité des données à partir de plusieurs threads Go tout en évitant les conditions de concurrence ?

Collecte sécurisée de données à partir de plusieurs threads dans Go

L'accès simultané à des données partagées sur plusieurs threads sans synchronisation appropriée peut entraîner un comportement indéfini dans Go. Ceci est particulièrement critique pour les scénarios impliquant à la fois des opérations de lecture et d'écriture.

Risques d'accès simultanés

Dans votre cas, plusieurs threads de travail s'exécutent en parallèle, tandis que le thread principal cherche périodiquement à collecter des valeurs auprès de ces travailleurs. Si rien n'est fait, des situations de concurrence critique peuvent survenir, dans lesquelles plusieurs threads tentent d'accéder simultanément aux mêmes données, ce qui risque de les corrompre.

Options de synchronisation

Pour éviter les problèmes d'accès simultanés, vous devez utiliser des mécanismes de synchronisation. Une approche couramment utilisée consiste à utiliser les canaux, qui facilitent l'échange sécurisé de données entre les goroutines. Cependant, dans votre cas, les canaux ne constituent peut-être pas l'option la plus efficace, car vous cherchez à récupérer les données des travailleurs plutôt que de les laisser les envoyer de manière proactive.

Données protégées par Mutex

Une solution plus adaptée consiste à protéger la structure de données partagée à l'aide d'une primitive de synchronisation telle qu'un sync.RWMutex. Ce verrou garantit qu'un seul thread peut modifier les données à la fois tout en permettant à plusieurs threads d'y accéder simultanément pour la lecture.

Exemple d'implémentation

Voici une implémentation simplifiée utilisant a sync.RWMutex :

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

Dans cet exemple, la méthode Iter du travailleur acquiert un verrou en lecture et renvoie le courant nombre d'itérations. La méthode setIter acquiert un verrou en écriture, met à jour le nombre d'itérations et libère le verrou.

Vous pouvez également utiliser le package sync/atomic pour fournir des opérations atomiques sur un compteur entier, éliminant ainsi le besoin d'un verrouillage explicite :

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

En utilisant des techniques de synchronisation appropriées, vous pouvez collecter en toute sécurité des données à partir de plusieurs threads dans Go, garantissant ainsi l'intégrité des données et évitant les conditions de concurrence.

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!