Go Programmation simultanée : cohérence des données et opérations atomiques

En programmation concurrente, il est important d'assurer la cohérence des données. Go fournit des verrous mutex et des opérations atomiques pour gérer les données partagées. Les mutex permettent à une goroutine d'accéder aux données à la fois, tandis que les opérations atomiques garantissent l'atomicité et la visibilité des écritures individuelles en mémoire.

Go Concurrent Programming : Cohérence des données et opérations atomiques

Introduction

En programmation simultanée, lorsque plusieurs goroutines accèdent aux données partagées en même temps, il est crucial d'assurer la cohérence des données. Go fournit certains mécanismes intégrés, tels que les verrous mutex et les valeurs atomiques, pour aider les développeurs à gérer les données partagées et à garantir leur cohérence.

Mutex

Un mutex est un mécanisme qui permet à une goroutine d'accéder à des données partagées à la fois. Lorsqu'une goroutine acquiert un mutex, les autres goroutines seront bloquées jusqu'à ce que le mutex soit libéré.

import (
    "fmt"
    "sync"
)

var (
    mu sync.Mutex
    counter int
)

func incrementCounter() {
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    // 创建多个goroutine并行增加计数器
    for i := 0; i < 1000; i++ {
        go incrementCounter()
    }

    // 等待所有goroutine完成
    time.Sleep(100 * time.Millisecond)

    fmt.Println("最终计数器值：", counter)
}

Opérations atomiques

Les opérations atomiques sont un ensemble d'opérations de bas niveau qui peuvent être exécutées simultanément par plusieurs goroutines. Elles garantissent qu'une seule opération d'écriture en mémoire est ininterrompue. Cela garantit l’atomicité et la visibilité des opérations de mémoire.

import (
    "fmt"
    "sync/atomic"
)

var counter int64

func incrementCounter() {
    atomic.AddInt64(&counter, 1)
}

func main() {
    // 创建多个goroutine并行增加计数器
    for i := 0; i < 1000; i++ {
        go incrementCounter()
    }

    // 等待所有goroutine完成
    time.Sleep(100 * time.Millisecond)

    fmt.Println("最终计数器值：", counter)
}

Conclusion

Les verrous Mutex et les opérations atomiques sont des outils importants dans la programmation simultanée Go pour gérer les données partagées et assurer la cohérence des données. En utilisant correctement ces mécanismes, les développeurs peuvent écrire du code concurrent, fiable et correct.

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!