How to avoid data race in concurrent programming of Golang functions

Methods to avoid data competition in Go include: using synchronization primitives (such as mutex locks, read-write locks) to control access to shared data; using atomic operations to ensure the atomicity of operations; using concurrency-safe data structures ( Such as sync.Map, sync.WaitGroup); Practical case: Use a mutex lock to avoid data competition on the count variable and ensure that only one goroutine can modify it at a time.

How to avoid data race in concurrent programming of Go functions

Data race is a common problem in concurrent programming. Occurs when multiple concurrent goroutines access shared data at the same time. In Go, data races can be avoided in a variety of ways, including:

• Using synchronization primitives: Synchronization primitives, such as mutex locks and read-write locks, can be used to control access to shared data. When using synchronization primitives, you need to ensure that these primitives are acquired and released at the correct moment.
• Use atomic operations: Atomic operations can ensure the atomicity of a series of operations in a concurrent environment, thereby avoiding data competition. There are various atomic operations provided in Go, such as atomic.AddInt32 and atomic.LoadUint64.
• Use concurrency-safe data structures: Go provides some concurrency-safe data structures, such as sync.Map and sync.WaitGroup, which can automatically handle data races.

Practical case:

The following example shows how to use a mutex to avoid data competition:

import (
    "fmt"
    "sync"
    "sync/atomic"
)

// 共享数据
var count int32

func increment() {
    // 获取互斥锁
    mutex.Lock()
    defer mutex.Unlock() // 该行确保在函数退出时释放互斥锁

    // 对共享数据进行修改
    count++
}

func main() {
    // 创建互斥锁
    var mutex sync.Mutex

    // 并发执行 100 次 increment 函数
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment()
        }()
    }

    // 等待所有 goroutine 完成
    wg.Wait()

    // 输出最终计数
    fmt.Println(atomic.LoadInt32(&count))
}

In this case, mutex The mutex lock is used to ensure that only one goroutine can access and modify the count variable at a time, thereby avoiding data competition.

The above is the detailed content of How to avoid data race in concurrent programming of Golang functions. For more information, please follow other related articles on the PHP Chinese website!