Problèmes de sécurité de la mémoire dans la programmation simultanée des fonctions Golang

La programmation simultanée des fonctions dans Go présente des problèmes de sécurité de la mémoire. Les solutions incluent : le verrouillage mutex : empêche plusieurs goroutines d'accéder aux données partagées en même temps et protège les sections critiques via des opérations de verrouillage et de déverrouillage. Canal : utilisé pour transférer en toute sécurité des valeurs entre les goroutines afin de garantir l'ordre des valeurs. Groupe d'attente synchrone : coordonne l'exécution simultanée de plusieurs goroutines pour garantir que le programme principal ne continue qu'une fois toutes les goroutines terminées.

Problèmes de sécurité de la mémoire dans la programmation concurrente des fonctions Golang

En programmation concurrente, il est crucial d'assurer la sécurité de la mémoire. Dans Go, les goroutines sont des primitives de concurrence légères qui posent des défis uniques en matière de sécurité de la mémoire.

Lorsque plusieurs goroutines accèdent simultanément à la mémoire partagée, des courses de données peuvent se produire, entraînant des données incohérentes ou corrompues. La clé pour résoudre ce problème est d’utiliser le mécanisme de synchronisation correct, tel que les mutex et les canaux.

Verrouillage mutex

Un verrouillage mutex est un mécanisme de synchronisation qui permet à une seule goroutine d'accéder aux données partagées dans une section critique à la fois. Le principe de base est de protéger les sections critiques par des opérations de verrouillage et de déverrouillage.

var mu sync.Mutex

func incrementValue(ptr *int) {
    mu.Lock()
    defer mu.Unlock()
    *ptr++
}

Channels

Les canaux sont un outil de base pour implémenter la concurrence dans Go, qui permet de transmettre des valeurs en toute sécurité entre les goroutines. Le canal lui-même est séquentiel, ce qui signifie que les valeurs ne peuvent être reçues que dans l'ordre dans lequel elles ont été envoyées.

ch := make(chan int)

go func() {
    for i := 0; i < 10; i++ {
        ch <- i
    }
}

func main() {
    for i := 0; i < 10; i++ {
        fmt.Println(<-ch)
    }
}

Cas pratique

Considérons l'exemple suivant, dans lequel deux goroutines modifient la variable partagée count en même temps : count：

var count int

func incrementCount() {
    count++
}

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        for i := 0; i < 50000; i++ {
            incrementCount()
        }
        wg.Done()
    }()

    go func() {
        for i := 0; i < 50000; i++ {
            incrementCount()
        }
        wg.Done()
    }()

    wg.Wait()
    fmt.Println(count)
}

如果不加同步，则最终的 count 值可能会小于 100000，并且可能随着 goroutine 数的增加而有极大的差异。通过使用互斥锁，可以防止这种情况发生：

var count int
var mu sync.Mutex

func incrementCount() {
    mu.Lock()
    defer mu.Unlock()
    count++
}

使用互斥锁，countrrreee

Si aucune synchronisation n'est ajoutée, le count final Valeur Elle peut être inférieure à 100 000 et peut varier considérablement à mesure que le nombre de goroutines augmente. Cela peut être évité en utilisant un mutex : 🎜rrreee🎜Avec un mutex, la valeur finale de count est toujours 100 000 et n'est pas affectée par le nombre de goroutines. 🎜

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!