Explorez les caractéristiques d'atomicité de l'affectation des variables Golang

Explorer l'atomicité de l'affectation de variables dans Golang

Introduction :
En programmation simultanée, il est très important de garantir l'atomicité des données. L'atomicité signifie que les opérations sur les mêmes données sont indivisibles, ou toutes soit l'exécution réussit, soit. aucune exécution n'a lieu. Golang fournit certaines opérations atomiques, telles que la fonction d'opération atomique dans le package atomique, qui peuvent être utilisées pour garantir l'atomicité des opérations d'affectation de variables.
Cet article explorera l'atomicité de l'affectation de variables dans Golang, la démontrera et la vérifiera à travers des exemples de code spécifiques.

1. Fonctions d'opération atomique dans Golang
Le package atomique de Golang fournit une série de fonctions d'opération atomique, les plus couramment utilisées sont les suivantes :

1. atomic.AddInt32(&var, val) : Ajoutez val atomiquement à la valeur de var. et renvoie la nouvelle valeur.
2. atomic.AddInt64(&var, val) : ajoute atomiquement val à la valeur de var et renvoie la nouvelle valeur.
3. atomic.AddUint32(&var, val) : ajoute atomiquement val à la valeur de var et renvoie la nouvelle valeur.
4. atomic.AddUint64(&var, val) : ajoute atomiquement val à la valeur de var et renvoie la nouvelle valeur.
5. atomic.LoadInt32(&var) : récupère la valeur de var de manière atomique et renvoie-la.
6. atomic.LoadInt64(&var) : récupère la valeur de var de manière atomique et renvoie-la.
7. atomic.LoadUint32(&var) : récupère la valeur de var de manière atomique et renvoie-la.
8. atomic.LoadUint64(&var) : récupère la valeur de var de manière atomique et renvoie-la.
9. atomic.StoreInt32(&var, val) : stocke val dans var de manière atomique.
10. atomic.StoreInt64(&var, val) : stocke val dans var de manière atomique.
11. atomic.StoreUint32(&var, val) : stocke val dans var de manière atomique.
12. atomic.StoreUint64(&var, val) : stocke val dans var de manière atomique.

2. Exemple d'atomicité d'affectation de variable
Ce qui suit utilise un exemple spécifique pour illustrer l'atomicité d'affectation de variable.

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var (
    count int32
    wg    sync.WaitGroup
)

func increaseCount() {
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&count, 1)
    }
    wg.Done()
}

func main() {
    wg.Add(2)
    go increaseCount()
    go increaseCount()
    wg.Wait()
    fmt.Println("Count: ", count)
}

Dans le code ci-dessus, une variable globale count et un groupe d'attente wg sont définis. La fonction IncreaseCount implémente l'opération d'auto-incrémentation sur la variable count en utilisant la fonction atomic.AddInt32, en augmentant de 1 à chaque fois. Dans la fonction principale, deux goroutines sont démarrées pour exécuter la fonction IncreaseCount. Chaque goroutine s'incrémente 10 000 fois et génère finalement la valeur de comptage via fmt.Println.

Exécutez le code ci-dessus et les résultats sont les suivants :

Count: 20000

Vous pouvez voir qu'en raison de l'utilisation de la fonction d'opération atomique atomic.AddInt32, l'atomicité de l'opération d'auto-incrémentation sur la variable de comptage est garantie, et le le résultat correct est finalement obtenu.

3. Exemple sans garantie d'atomicité
Regardons un exemple sans garantie d'atomicité.

package main

import (
    "fmt"
    "sync"
)

var (
    count int32
    wg    sync.WaitGroup
)

func increaseCount() {
    for i := 0; i < 10000; i++ {
        count += 1  // count的自增操作不是原子性的
    }
    wg.Done()
}

func main() {
    wg.Add(2)
    go increaseCount()
    go increaseCount()
    wg.Wait()
    fmt.Println("Count: ", count)
}

Dans le code ci-dessus, l'opération count += 1 dans la fonction IncreaseCount n'est pas atomique, donc des conditions de concurrence peuvent se produire lors d'une exécution simultanée, entraînant des résultats incorrects.

Exécutez le code ci-dessus, les résultats peuvent être les suivants (les résultats peuvent être différents à chaque fois) :

Count:  15923

Vous pouvez voir que parce que l'atomicité de l'opération d'auto-incrémentation du nombre n'est pas garantie, le résultat final est faux.

IV. Conclusion
Grâce aux exemples de code ci-dessus, nous pouvons tirer les conclusions suivantes :

1. Le package atomique de Golang fournit certaines fonctions d'opération atomique, qui peuvent être utilisées pour garantir l'atomicité des opérations d'affectation de variables.
2. En programmation simultanée, l'utilisation de fonctions d'opération atomiques peut éviter les conditions de concurrence et garantir l'exactitude des données.

Résumé :
Lors de l'écriture de programmes concurrents, afin de garantir l'atomicité des opérations sur les données, nous pouvons utiliser les fonctions d'opération atomique dans le package atomique fourni par Golang. Ces fonctions peuvent garantir que les opérations sur les variables partagées sont atomiques, évitant ainsi l'apparition de conditions de concurrence critique et garantissant l'exactitude des données. Grâce à l'exemple de démonstration de code présenté dans cet article, les lecteurs peuvent avoir une compréhension plus approfondie de l'atomicité de l'affectation de variables dans Golang et utiliser rationnellement les fonctions d'opération atomique dans le développement réel pour améliorer la stabilité et les performances du programme.

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!