Is variable assignment an atomic operation in Golang?

Whether variable assignment in Golang has atomic operations requires specific code examples

In programming, atomic operations refer to operations that cannot be interrupted, that is, either all are executed successfully , or none of them are executed. In concurrent programming, the importance of atomic operations is self-evident, because in concurrent programs, multiple threads (or goroutines) may access and modify the same variable at the same time. If there are no atomic operations, race conditions will occur.

Golang, as a programming language that supports concurrency, also provides support for atomic operations. For the operation of variable assignment, Golang provides the sync/atomic package to implement atomic operations.

Let’s look at a simple example first:

package main

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

var count int64

func increment(wg *sync.WaitGroup) {
    atomic.AddInt64(&count, 1)
    wg.Done()
}

func main() {
    var wg sync.WaitGroup
    wg.Add(100)

    for i := 0; i < 100; i++ {
        go increment(&wg)
    }

    wg.Wait()

    fmt.Println("Count:", count)
}

In the above code, we define a global variable count and use int64 type representation. Next, we defined an increment function, which uses the atomic.AddInt64 function to implement the atomic addition operation to the count variable. Finally, we use sync.WaitGroup to wait for all increment functions to complete and print out the value of count.

If we run this code, you will find that the value of count output must be 100. This is because the atomic.AddInt64 function has atomic operations. When multiple goroutines access and modify the count variable at the same time, each goroutine will increase the count in sequence. value, no race conditions will occur.

So, what will happen if we modify atomic.AddInt64 in the above code to a normal assignment operation?

// 使用普通的赋值操作
func increment(wg *sync.WaitGroup) {
    count += 1
    wg.Done()
}

If we run this code, you may see that the output count value may be less than 100. This is because ordinary assignment operations are not atomic. When multiple goroutines increase the count variable at the same time, a race condition will occur. This also shows that ordinary assignment operations in Golang are not atomic.

In summary, whether variable assignment operations in Golang are atomic operations depends on the assignment method used. If you use the atomic operation function in the sync/atomic package, then the assignment operation is atomic. If a normal assignment operation is used, there is no atomicity and race conditions may occur. In concurrent programming, in order to avoid race conditions, we try to use atomic operations.

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