Quand et pourquoi devriez-vous utiliser « atomic.LoadInt64 » dans Go ?

Atomic LoadInt32/StoreInt32 (64)

Les opérations de mémoire atomique garantissent que les accès conflictuels à une variable partagée à partir de plusieurs goroutines se produisent dans un ordre défini , garantissant la cohérence des données. Le package sync/atomic fournit des opérations de chargement et de stockage atomiques pour différents types de données, notamment int32 et int64.

Comprendre la différence

À la fois int64(&sharedA) et atomique. LoadInt64(&sharedA) effectue des charges atomiques. Cependant, ce dernier utilise explicitement le package sync/atomic pour assurer l'ordre de la mémoire. Ceci est important lors de l'accès à des variables partagées qui peuvent être modifiées simultanément par plusieurs goroutines.

L'utilisation de LoadInt64 garantit que :

• La valeur dans sharedA est lue de manière atomique, ce qui signifie qu'aucune autre goroutine ne peut modifier pendant l'opération.
• L'opération de lecture est synchronisée avec toutes les opérations de mémoire antérieures. Cela signifie que d'autres goroutines observeront la valeur de sharedA après qu'elle ait été mise à jour par la charge atomique.

Exemple d'utilisation

Les charges et les magasins atomiques sont généralement utilisé dans des scénarios où :

• Plusieurs goroutines accèdent simultanément aux données partagées.
• L'ordre des opérations de mémoire est essentiel pour la cohérence des données.
• Il est essentiel de prévenir les courses aux données.

Considérez l'exemple suivant :

<code class="go">package main

import "sync/atomic"

func main() {
    // Shared variables
    var sharedA int64
    var sharedB *int64

    // Concurrent code
    go func() {
        // Set sharedA to 10
        atomic.StoreInt64(&sharedA, 10)
    }()

    go func() {
        // Set sharedB to a new value
        sharedB = new(int64)
        *sharedB = 20
    }()

    // Main goroutine reads shared variables
    tmpVarA := atomic.LoadInt64(&sharedA)
    tmpVarB := atomic.LoadInt64(sharedB)

    // Print the values
    println(tmpVarA, *tmpVarB)
}</code>

Dans cet exemple, l'opération StoreInt64 garantit que plusieurs goroutines modifient simultanément sharedA et sharedB sans provoquer de courses de données. Le LoadInt64 garantit que la goroutine principale lit systématiquement les dernières valeurs de ces variables partagées.

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!