In this article, we will explore the StoreInt32() Function in sync/atomic package in Go in details, along with examples.
The StoreInt32 function is a member of the “sync/atomic” package in Go, which provides low-level atomic memory operations. This function atomically sets the value of an int32 variable. It is a write operation that ensures the value written is immediately visible to other concurrent threads. The function signature is as follows:
Syntax:
func StoreInt32(addr *int32, val int32)
The function takes a pointer to an int32 variable addr and an int32 value val as arguments. It sets the value of addr to val atomically.
Example
To illustrate the usage of the StoreInt32 function, let’s create a simple program simulating concurrent data access. We will create two goroutines: one that sets a shared flag to a specific value using the StoreInt32 function and another that reads and prints the flag value using the atomic.LoadInt32 function.
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
func main() {
var flag int32 = 0
var wg sync.WaitGroup
// Writer goroutine
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 5; i++ {
atomic.StoreInt32(&flag, int32(i+1))
fmt.Printf("Writer: Flag set to %d\n", i+1)
time.Sleep(time.Millisecond * 500)
}
}()
// Reader goroutine
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 10; i++ {
fmt.Printf("Reader: Current flag value is %d\n", atomic.LoadInt32(&flag))
time.Sleep(time.Millisecond * 250)
}
}()
wg.Wait()
}
In this example, we use the sync.WaitGroup to ensure that both goroutines complete before the program exits. The writer goroutine sets the flag value using the atomic.StoreInt32 function, ensuring atomicity. Meanwhile, the reader goroutine reads the flag value using the atomic.LoadInt32 function, guaranteeing that it always reads the latest value written by the writer goroutine.
This example demonstrates how the StoreInt32 function can be used to perform atomic write operations on a shared int32 variable, ensuring data consistency across concurrent threads.
Conclusion
The StoreInt32 function is a valuable utility provided by the sync/atomic package in Go, enabling atomic write operations on int32 variables. It is particularly useful in concurrent programming when multiple goroutines access shared memory. Using the StoreInt32 function ensures data consistency and helps eliminate race conditions, contributing to the overall stability and reliability of your concurrent Go applications.
To check more Go related articles. Pls click given below link:
https://www.techieindoor.com/go-loaduintptr-in-sync-atomic-package/
https://pkg.go.dev/net/[email protected]