La meilleure fa?on de détecter les conditions de course dans GO est d'utiliser le détecteur de course intégré avec le drapeau -Race. 1. Run Go Run -Race Main.go ou go test -RACE. / ... pour activer le détecteur de course, qui identifie l'accès en lecture simultané aux variables partagées et fournit des rapports détaillés, y compris des traces de goroutine et des types d'accès. 2. écrivez des tests qui exercent activement la concurrence en utilisant plusieurs goroutines, boucles et synchronisés. 3. évitez les modèles communs à la race tels que l'accès non synchronisé aux variables globales, l'utilisation de la fermeture incorrecte dans les boucles et les structures partagées non protégées en utilisant sync.mutex, canaux ou sync / atomiques pour une concurrence s?re. 4. Compléter la détection dynamique avec analyse statique à l'aide de GO Vet. / ... pour prendre des problèmes de base, bien qu'il ne puisse pas détecter la plupart des races. Le détecteur de course est essentiel pendant le développement et les tests, en particulier dans les pipelines CI, et doit être utilisé régulièrement parce que les conditions de race se manifestent souvent en silence sans accidents, ce qui signifie que le code simultané non testé contient probablement des races non détectées.

Les conditions de course dans GO peuvent être difficiles à repérer car elles ne provoquent pas toujours des accidents ou des bugs évidents - ils peuvent tout simplement conduire à un comportement incohérent ou incorrect sous charge. Heureusement, Go fournit un outil intégré pour aider à les détecter: le détecteur de course .

Utilisez le détecteur de course Go

Le moyen le plus efficace de vérifier les conditions de course est d'activer le détecteur de course intégré de Go en ajoutant l'indicateur -race lors de l'exécution de votre programme:

 Go Run -Race Main.go

Ou lors des tests:

 Allez tester -RACE. / ...

Cet drapeau instrument votre code pour détecter un accès simultané aux variables partagées où un accès est une écriture. Lorsqu'une course est détectée, l'outil imprime un rapport détaillé montrant:

• Que les Goroutines ont accédé à la variable
• La pile trace pour chaque accès
• Que l'accès était une lecture ou une écriture

Par exemple, si deux Goroutines lisent et écrivent la même variable sans synchronisation:

 var compteur int

func main () {
    aller func () {
        comptoir  
    } ()
    aller func () {
        comptoir  
    } ()
    Time.Sleep (time.second)
}

Running go run -race rapportera probablement une course de données sur counter .

écrire des tests qui font de la concurrence

Le détecteur de course ne capture que des courses qui se produisent réellement pendant l'exécution. Vous devez donc créer des scénarios de test qui soulignent l'exécution simultanée.

Conseils:

• Exécutez des tests avec plusieurs Goroutines accédant à l'état partagé.
• Utilisez des boucles pour augmenter les risques d'exécution qui se chevauchent.
• Ajoutez time.Sleep appelle avec parcimonie (uniquement pour la démonstration - élue dans les tests réels).
• Préférez l'utilisation de sync.WaitGroup pour coordonner les goroutines dans les tests.

Exemple de test:

 func testcounter (t * test.t) {
    var compteur int
    var wg sync.waitgroup

    pour i: = 0; i <10; je {
        wg.add (1)
        aller func () {
            différer wg.done ()
            COMPTER // RACE!
        } ()
    }
    wg.wait ()
}

Courez avec go test -race pour prendre la course.

évitez les modèles communs qui provoquent des courses

Même avec le détecteur de course, il aide à reconna?tre les modèles dangereux:

• Accès non synchronisé aux variables globales
• Les fermetures capturant les variables de boucle (bien que GO 1.22 l'améliore)
• Structs partagés sans protection mutex

Plut?t:

• Utilisez sync.Mutex ou sync.RWMutex pour protéger les données partagées.
• Utilisez des canaux pour transmettre la propriété au lieu de partager la mémoire.
• Considérez sync/atomic pour les opérations atomiques simples (par exemple, atomic.AddInt64 ).

Utilisez des outils d'analyse statique (aide limitée)

Bien que le détecteur de course soit dynamique (besoin d'exécution), des outils comme go vet peuvent attraper des constructions suspectes, bien qu'elles ne trouvent pas la plupart des races. Pourtant, toujours courir:

 aller vétérinaire. / ...

Il peut attraper des erreurs évidentes, comme verrouiller le mauvais mutex ou copier des structures verrouillées.

Conclusion: le drapeau -race est votre meilleur ami. Utilisez-le régulièrement lors des tests, en particulier dans les pipelines CI. Il a des performances et des frais généraux de mémoire, alors laissez-le en production, mais ne le sautez jamais pendant le développement et les tests.

Fondamentalement, si vous écrivez du code GO simultané et n'utilisez pas -race , vous expédiez probablement des courses.

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!