Atomic analysis and application discussion of Golang variable assignment

Atomic analysis and application of variable assignment in Golang

In concurrent programming, the atomicity of variables is a very important concept. In a single-threaded environment, variable assignment and read operations are atomic operations, that is, these operations will not be interrupted. However, in a multi-threaded environment, since multiple threads will access the same variable at the same time, if appropriate measures are not taken, problems such as data competition will occur.

In Golang, atomic operations can be performed by using the sync/atomic package. This package provides some atomic operation functions, such as AddInt32, AddInt64, CompareAndSwapInt32, CompareAndSwapInt64, SwapInt32, SwapInt64, etc., which can ensure the atomicity of variable assignment and read operations, thus effectively solving the problem of data competition in multi-threads.

Below, we will discuss the atomic analysis and application of variable assignment in Golang through specific code examples.

Example 1: Atomic operation

The following code is used to simulate multi-threaded operations on shared variables. We defined a global variable count, and then created 100 coroutines. Each coroutine added 1 to count 10,000 times. Finally, output the value of count to verify its correctness.

package main

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

var count int32
var wg sync.WaitGroup

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go add()
    }
    wg.Wait()
    fmt.Println(count)
}

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&count, 1)
    }
}

The running results are as follows:

1000000

You can see that the output result is 1000000, that is to say, the operation of adding 1 to count by 100 coroutines is atomic, no A data race problem occurs.

Example 2: Non-atomic operation

The following code is also used to simulate multi-threaded operations on shared variables. Similarly, we define a global variable count, and then create 100 coroutines. Each coroutine adds 1 to count 10,000 times. But this time we do it using normal addition instead of using atomic.AddInt32. Finally, output the value of count to verify its correctness.

package main

import (
    "fmt"
    "sync"
)

var count int32
var wg sync.WaitGroup

func main() {
    wg.Add(100)
    for i := 0; i < 100; i++ {
        go add()
    }
    wg.Wait()
    fmt.Println(count)
}

func add() {
    defer wg.Done()
    for i := 0; i < 10000; i++ {
        count++
    }
}

The running results are as follows:

524999

As you can see, the output result is 524999, not the expected 1000000. This is because in a multi-threaded environment, count is not an atomic operation and may be interrupted. If multiple coroutines modify count at the same time, data competition problems will occur, resulting in incorrect results. Therefore, in a multi-threaded environment, we need to use atomic operations to ensure that variable modifications are atomic.

Summary

In Golang, atomic operations can be performed by using the sync/atomic package. This package provides some atomic operation functions to ensure the atomicity of variable assignment and read operations. When using multi-threaded concurrent programming, these atomic operation functions can be used to avoid problems such as data competition and ensure the correctness and stability of the program.

The above is the detailed content of Atomic analysis and application discussion of Golang variable assignment. For more information, please follow other related articles on the PHP Chinese website!