La fonction Append est-elle thread-safe pour une utilisation simultanée de Goroutine ?

L'ajout n'est-il pas thread-safe pour une utilisation simultanée par plusieurs goroutines ?

Lors de l'utilisation de goroutines pour ajouter simultanément des données à une tranche dans une boucle , vous pouvez rencontrer des incohérences, telles que des éléments manquants ou dupliqués. Ce scénario soulève la question de savoir si la fonction append n'est pas thread-safe pour une utilisation simultanée par plusieurs goroutines.

La réponse : courses de données et manque de sécurité des threads

Dans Go, aucune valeur n'est sûre pour la lecture/écriture simultanée, y compris les tranches (ou plus précisément les en-têtes de tranche). Lorsque plusieurs goroutines tentent de modifier simultanément la même tranche, des courses de données se produisent, conduisant potentiellement à un comportement inattendu.

Vérification de la course aux données

Vous pouvez exécuter votre code avec le - option race pour confirmer la présence de courses de données :

go run -race play.go

Solution : Synchronisation

Pour résoudre ce problème et assurer la cohérence des données, vous devez synchroniser l'accès au slice lors de l’écriture simultanée d’éléments. Ceci peut être réalisé en utilisant un sync.Mutex :

var mu = &sync.Mutex{}
destSlice := make([]myClass, 0)

var wg sync.WaitGroup
for _, myObject := range sourceSlice {
    wg.Add(1)
    go func(closureMyObject myClass) {
        defer wg.Done()
        var tmpObj myClass
        tmpObj.AttributeName = closureMyObject.AttributeName
        mu.Lock()
        destSlice = append(destSlice, tmpObj)
        mu.Unlock()
    }(myObject)
}
wg.Wait()

En acquérant le mutex avant de l'ajouter à la tranche et en le libérant par la suite, vous vous assurez qu'une seule goroutine a un accès en écriture à la fois, empêchant ainsi la corruption des données.

Conclusion

Bien que les éléments de tranche se comportent comme des variables distinctes et peuvent être modifiés simultanément, les en-têtes de tranche ne sont pas intrinsèquement thread-safe. Pour garantir des opérations d'écriture simultanées sûres et cohérentes, il est crucial d'utiliser des mécanismes de synchronisation tels que des mutex ou des canaux lors de la modification des en-têtes de tranche dans les goroutines.

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!