Comment les opérations simultanées de lecture et d'écriture sur les structures Go peuvent-elles conduire à des courses aux données ?

Go Struct Lecture et écriture simultanées : pourquoi des courses de données peuvent se produire

Dans Go, les opérations de lecture et d'écriture simultanées sur des structures sans verrous peuvent potentiellement conduire à des courses aux données. Bien que cela n'entraîne pas toujours des erreurs fatales, il est crucial de comprendre les problèmes sous-jacents.

Le problème de la course aux données dans les structures

Une course aux données se produit lorsque plusieurs goroutines simultanément accéder à une variable partagée et au moins un de ces accès est une écriture. Dans le cas des structures, cela signifie que deux goroutines ou plus peuvent lire ou écrire différents champs de la même structure en même temps.

Considérez l'exemple suivant, où plusieurs goroutines lisent et écrivent simultanément une structure de métadonnées. :

type Metadata struct {
    key bool
}

func concurrentStruct() {
    m := new(Metadata)

    for i := 0; i < 100000; i++ {
        go func(metadata *Metadata) {
            for {
                readValue := metadata.key
                if readValue {
                    metadata.key = false
                }
            }
        }(m)

        go func(metadata *Metadata) {
            for {
                metadata.key = true
            }
        }(m)
    }
    select {}
}

Cet exemple s'exécute avec un AVERTISSEMENT : DATA RACE, mais n'entraîne pas d'erreur fatale. En effet, la course aux données ne se produit que sur un seul champ de la structure (le champ clé). Puisque les autres champs ne sont pas accessibles, la structure reste stable et le programme peut continuer à fonctionner.

Résoudre la course aux données

Pour éliminer les courses aux données, vous devez synchroniser les accès concurrents à la structure à l'aide d'un verrou. Une façon d'y parvenir consiste à utiliser un mutex en lecture-écriture, comme le montre l'exemple suivant :

type Metadata struct {
    mu  sync.RWMutex
    key bool
}

func concurrentStructWithMuLock() {
    m := new(Metadata)

    go func(metadata *Metadata) {
        for {
            metadata.mu.Lock()
            readValue := metadata.key
            if readValue {
                metadata.key = false
            }
            metadata.mu.Unlock()
        }
    }(m)

    go func(metadata *Metadata) {
        for {
            metadata.mu.Lock()
            metadata.key = true
            metadata.mu.Unlock()
        }
    }(m)
    select {}
}

Avec l'ajout du mutex en lecture-écriture, la course aux données est éliminée et le programme s'exécute sans message d'erreur. En effet, le mutex garantit qu'une seule goroutine peut accéder à la structure à la fois.

En conclusion, les opérations de lecture et d'écriture simultanées sur les structures dans Go peuvent entraîner des courses de données, même si la structure comporte plusieurs champs. Il est crucial d'utiliser des mécanismes de synchronisation, tels que les mutex en lecture-écriture, pour éviter les courses de données et garantir le bon fonctionnement des programmes concurrents.

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!