Why are variable values ​​in my Go program out of sync across different threads?

In the Go language, using coroutines to implement concurrent operations has become a very popular way. However, when variables are shared among multiple coroutines, data race problems can easily occur. A data race is a concurrent programming bug that occurs when two or more threads try to read or write the same memory location at the same time. In this case, the program may produce unpredictable and erroneous results.

In the Go language, in order to avoid this situation, you can use mechanisms such as mutex locks to solve it.

Use of mutex lock

Mutex lock is a lock used in Go language to synchronously access shared resources. When a coroutine needs to access a shared resource, it needs to obtain a mutex first and then perform the operation. After the operation is completed, the mutex lock needs to be released so that other coroutines can continue to access the shared resources.

The mutex lock is used as follows:

import "sync"

var mu sync.Mutex // 互斥锁

func main() {
    // ...

    mu.Lock() // 获取互斥锁
    // 访问共享资源
    mu.Unlock() // 释放互斥锁

    // ...
}

In the above code, the Lock() method is used to obtain the mutex lock, Unlock() Method is used to release the mutex lock. When a coroutine acquires a mutex lock, other coroutines must wait for it to release the mutex lock before they can acquire the mutex lock. This avoids data race problems.

Example

The following is an example that demonstrates how to use a mutex lock to solve the problem of data competition.

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    count := 0
    mu := sync.Mutex{}

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            count++
            mu.Unlock()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println("count: ", count)
}

In the above code, we first define a WaitGroup object to record the number of coroutines. Then define a mutex lock mu and a counter count. Then 100 coroutines are started, and each coroutine increases the counter by one. Since the counter count is a shared resource, it is necessary to obtain the mutex lock before the operation and release the mutex lock after the operation is completed. Finally, use the Wait() method to wait for all coroutines to end and print the counter value.

The operation results are as follows:

count:  100

Judging from the results, the operation was successful. At this point the variable values ​​are synchronized in different threads.

Summary

When using coroutines for concurrent operations in the Go language, multiple coroutines may access the same shared resource, so you need to pay attention to the issue of data competition. Mutex lock is a kind of lock used to solve data competition, which can effectively avoid the problem of multiple coroutines accessing the same shared resource at the same time. By using mutex locks, variable values ​​can be guaranteed to be synchronized in different threads.

The above is the detailed content of Why are variable values ​​in my Go program out of sync across different threads?. For more information, please follow other related articles on the PHP Chinese website!