Pourquoi « sync.Once » de Go utilise-t-il « atomic.StoreUint32 » au lieu de l'affectation normale pour définir l'indicateur « done » ?

Utilisation appropriée des opérations atomiques dans la synchronisation de Go.Une fois

Dans le contexte de la synchronisation de Go.Une fois la mise en œuvre, il est crucial de comprendre le distinction entre l'affectation normale et l'opération atomic.StoreUint32 lors de la définition de l'indicateur terminé.

L'implémentation incorrecte

Initialement, la fonction Do dans once.go a utilisé l'approche suivante :

if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
    f()
}

Cette implémentation ne garantit pas que l'exécution de f est complète au retour de Do. Deux appels simultanés à Do pourraient aboutir à ce que le premier appel appelle avec succès f, tandis que le deuxième appel revient prématurément, croyant que f est terminé, même si ce n'est pas le cas.

Opération du magasin atomique

Pour résoudre ce problème, Go utilise l'opération atomic.StoreUint32. Contrairement à l'affectation normale, atomic.StoreUint32 garantit la visibilité de l'indicateur terminé mis à jour pour les autres goroutines.

Considérations sur le modèle de mémoire

L'utilisation d'opérations atomiques en synchronisation.Once est pas principalement influencé par le modèle de mémoire de la machine sous-jacente. Le modèle de mémoire de Go agit comme une abstraction unificatrice, garantissant un comportement cohérent sur différentes plates-formes matérielles, quels que soient leurs modèles de mémoire spécifiques.

Chemin rapide optimisé

Pour optimiser les performances, synchronisez .Once utilise un chemin rapide pour les scénarios courants dans lesquels l'indicateur terminé est déjà défini. Ce chemin rapide utilise atomic.LoadUint32 pour vérifier l'indicateur terminé sans acquérir le mutex. Si l'indicateur est défini, la fonction revient immédiatement.

Chemin lent avec Mutex et Atomic Store

Lorsque le chemin rapide échoue (c'est-à-dire que terminé est initialement non défini), le chemin lent est entré. Un mutex est acquis pour garantir qu'un seul appelant peut procéder à l'exécution de f. Une fois f terminé, atomic.StoreUint32 est utilisé pour définir l'indicateur terminé, le rendant visible aux autres goroutines.

Lectures simultanées

Même si l'indicateur terminé est défini atomiquement, cela ne sécurise pas les lectures simultanées. La lecture du drapeau en dehors de la section critique protégée nécessite l’utilisation d’atomic.LoadUint32. Cependant, les lectures directes dans la section critique sont sûres car le mutex fournit une exclusion mutuelle.

En résumé, la synchronisation de Go.Once utilise atomic.StoreUint32 pour garantir la modification cohérente et visible de l'indicateur terminé, quel que soit le mémoire sous-jacente モデル et pour éviter les courses aux données. La combinaison d'opérations atomiques et de mutex offre à la fois des optimisations de performances et des garanties d'exactitude.

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!