Is variable assignment atomic in Golang?

Is variable assignment operation atomic in Golang? Need specific code examples

In the Go language, the atomicity of variable assignment operations is a common problem. Atomicity refers to the characteristic that an operation will not be interrupted during execution. Even if multiple threads access or modify the same variable at the same time, there will be no intermediate state. This is critical to the correctness of concurrent programs.

The Go language standard library provides the sync/atomic package for performing atomic operations. The atomic operations in this package ensure that the reading and modification of variables are atomic. However, it should be noted that the assignment operation itself is not an atomic operation in the Go language.

In order to better understand the atomicity issue of variable assignment operations, we can illustrate it through a specific code example.

The sample code is as follows:

package main

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

func main() {
    var count int32

    // 使用sync.WaitGroup等待goroutine执行完毕
    var wg sync.WaitGroup
    wg.Add(2)

    // 第一个goroutine执行count++，循环10万次
    go func() {
        defer wg.Done()
        for i := 0; i < 100000; i++ {
            count++
        }
    }()

    // 第二个goroutine执行count--，循环10万次
    go func() {
        defer wg.Done()
        for i := 0; i < 100000; i++ {
            count--
        }
    }()

    // 等待goroutine执行完毕
    wg.Wait()

    // 输出最终的count值
    fmt.Println(count)
}

In the above sample code, we created an int32 type variable count, and then defined two goroutines to countPerform addition and subtraction operations, each goroutine loops 100,000 times.

Since the count and count-- operations are not atomic, data may appear when multiple goroutines modify count at the same time. Competition issues. If the variable assignment operation is atomic, the final count value should be 0.

In order to ensure the atomicity of variable assignment operations, we can use the AddInt32 and SubInt32 functions in the sync/atomic package instead count and count-- operations, the code modification is as follows:

package main

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

func main() {
    var count int32

    // 使用sync.WaitGroup等待goroutine执行完毕
    var wg sync.WaitGroup
    wg.Add(2)

    // 第一个goroutine执行count++，循环10万次
    go func() {
        defer wg.Done()
        for i := 0; i < 100000; i++ {
            atomic.AddInt32(&count, 1)
        }
    }()

    // 第二个goroutine执行count--，循环10万次
    go func() {
        defer wg.Done()
        for i := 0; i < 100000; i++ {
            atomic.AddInt32(&count, -1)
        }
    }()

    // 等待goroutine执行完毕
    wg.Wait()

    // 输出最终的count值
    fmt.Println(count)
}

Through the above modifications, we use the atomic.AddInt32 function to ensure the variable assignment operation atomicity. After the modified code, the final output value of count is 0, which proves that the variable assignment operation is atomic here.

In summary, variable assignment operations are not atomic in the Go language, but we can use the atomic operations in the sync/atomic package to ensure the atomicity of variable assignments.

The above is the detailed content of Is variable assignment atomic in Golang?. For more information, please follow other related articles on the PHP Chinese website!