Comment atomic.LoadInt64 et atomic.StoreInt64 garantissent-ils la cohérence des données et l'ordre de la mémoire dans les programmes Go simultanés ?

Atomic LoadInt32 et StoreInt32 : comprendre leur importance

Le package sync/atomic de Golang fournit des opérations atomiques pour garantir que les opérations sur la mémoire partagée sont atomique, garantissant la cohérence entre les goroutines simultanées. Cela devient nécessaire lorsque plusieurs goroutines tentent d'accéder ou de modifier simultanément la même variable, ce qui peut conduire à des conditions de course aux données.

LoadInt64 et StoreInt64

atomic.LoadInt64 et atomique. StoreInt64 sont deux opérations atomiques spécifiques pour lire et écrire des entiers de 64 bits, respectivement. Pour illustrer leur utilisation, considérons le code suivant :

<code class="go">package main

import (
    "sync/atomic"
    "time"
)

var sharedCounter int64

func main() {
    go func() {
        for {
            v := atomic.LoadInt64(&sharedCounter) // Read sharedCounter using atomic load
            time.Sleep(10 * time.Millisecond)
            atomic.StoreInt64(&sharedCounter, v+1) // Increment sharedCounter using atomic store
        }
    }()

    go func() {
        for {
            time.Sleep(time.Second)
            v := atomic.LoadInt64(&sharedCounter) // Read sharedCounter again using atomic load
            println(v)
        }
    }()

    time.Sleep(60 * time.Second) // Keep the program running for some time to see updates
}</code>

Importance des opérations atomiques

Dans cet exemple, plusieurs goroutines partagent l'accès à la variable sharedCounter. Il est crucial d'y effectuer des opérations atomiques pour garantir que :

1. Lecture et écriture cohérentes : L'utilisation d'atomic.LoadInt64 pour la lecture et d'atomic.StoreInt64 pour l'écriture garantit que chaque opération est exécuté comme une unité atomique indivisible. Cela évite les courses de données où une goroutine pourrait voir l'état intermédiaire de la variable être modifié par une autre goroutine.
2. Ordre de la mémoire : Les opérations atomiques appliquent l'ordre de la mémoire, garantissant que la visibilité des écritures dans la variable partagée est cohérente dans toutes les goroutines. Cela signifie que v reflétera toujours la valeur la plus récente écrite par n'importe quelle goroutine, même si elle y accède de manière asynchrone.

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!