Analyse atomique et discussion sur l'application de l'affectation des variables Golang

Analyse atomique et application de l'affectation de variables dans Golang

En programmation concurrente, l'atomicité des variables est un concept très important. Dans un environnement monothread, les opérations d'affectation de variables et de lecture sont des opérations atomiques, c'est-à-dire que ces opérations ne seront pas interrompues. Cependant, dans un environnement multithread, puisque plusieurs threads accèderont à la même variable en même temps, si les mesures appropriées ne sont pas prises, des problèmes tels que la concurrence entre les données se produiront.

Dans Golang, les opérations atomiques peuvent être effectuées en utilisant le package sync/atomic. Ce package fournit certaines fonctions d'opération atomiques, telles que AddInt32, AddInt64, CompareAndSwapInt32, CompareAndSwapInt64, SwapInt32, SwapInt64, etc., qui peuvent garantir l'atomicité des opérations d'affectation de variables et de lecture, résolvant ainsi efficacement le problème de la concurrence des données dans les multi-threads.

Ci-dessous, nous explorerons l'analyse atomique et l'application de l'affectation de variables dans Golang à travers des exemples de code spécifiques.

Exemple 1 : Opération atomique

Le code suivant est utilisé pour simuler des opérations multithread sur des variables partagées. Nous définissons un nombre de variables globales, puis créons 100 coroutines. Chaque coroutine ajoute 1 pour compter 10 000 fois. Enfin, affichez la valeur de count pour vérifier son exactitude.

package main

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

var count int32
var wg sync.WaitGroup

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go add()
    }
    wg.Wait()
    fmt.Println(count)
}

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

Les résultats d'exécution sont les suivants :

1000000

Vous pouvez voir que le résultat de sortie est 1000000. En d'autres termes, les opérations d'ajout de 1 pour compter par 100 coroutines sont toutes atomiques et il n'y a pas de problème de concurrence de données.

Exemple 2 : Opération non atomique

Le code suivant est également utilisé pour simuler des opérations multithread sur des variables partagées. De même, nous définissons un nombre de variables globales, puis créons 100 coroutines. Chaque coroutine ajoute 1 pour compter 10 000 fois. Mais cette fois, nous le faisons en utilisant l'addition normale au lieu d'utiliser atomic.AddInt32. Enfin, affichez la valeur de count pour vérifier son exactitude.

package main

import (
    "fmt"
    "sync"
)

var count int32
var wg sync.WaitGroup

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go add()
    }
    wg.Wait()
    fmt.Println(count)
}

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        count++
    }
}

Les résultats en cours d'exécution sont les suivants :

524999

Vous pouvez voir que le résultat de sortie est 524999, et non le 1000000 attendu. En effet, dans un environnement multithread, count++ n'est pas une opération atomique et peut être interrompu. Si plusieurs coroutines modifient le décompte en même temps, des problèmes de concurrence de données se produiront, entraînant des résultats incorrects. Par conséquent, dans un environnement multithread, nous devons utiliser des opérations atomiques pour garantir que les modifications de variables sont atomiques.

Résumé

Dans Golang, les opérations atomiques peuvent être effectuées à l'aide du package sync/atomic. Ce package fournit des fonctions d'opération atomiques pour garantir l'atomicité des opérations d'affectation de variables et de lecture. Lors de l'utilisation d'une programmation simultanée multithread, ces fonctions d'opération atomique peuvent être utilisées pour éviter des problèmes tels que la concurrence des données et garantir l'exactitude et la stabilité 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!