Go Concurrent Programming: Data Consistency and Atomic Operations

In concurrent programming, it is important to ensure data consistency. Go provides mutex locks and atomic operations to manage shared data. Mutexes allow one goroutine to access data at a time, while atomic operations guarantee the atomicity and visibility of individual memory writes.

Go Concurrent Programming: Data Consistency and Atomic Operations

Introduction

In concurrent programming, when When multiple goroutines access shared data at the same time, it is crucial to ensure data consistency. Go provides some built-in mechanisms, such as mutex locks and atomic values, to help developers manage shared data and ensure its consistency.

Mutex lock

A mutex lock is a mechanism that allows a goroutine to access shared data at a time. When a goroutine acquires a mutex, other goroutines will be blocked until the mutex is released.

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)
}

Atomic operations

Atomic operations are a set of low-level operations that can be executed concurrently by multiple goroutines. They guarantee that a single write operation to memory is uninterruptible. This ensures atomicity and visibility of memory operations.

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

Mutex locks and atomic operations are important tools for handling shared data and ensuring data consistency in Go concurrent programming. By using these mechanisms correctly, developers can write code that is concurrent, reliable, and correct.

The above is the detailed content of Go Concurrent Programming: Data Consistency and Atomic Operations. For more information, please follow other related articles on the PHP Chinese website!