In this article, we will explore the StoreUint64() Function in sync/atomic package in Go in details, along with examples.
Introduction:
Concurrency is an essential aspect of modern software development, and Go is a language specifically designed to handle it efficiently. One of the critical features provided by Go is the “sync/atomic” package, which offers atomic memory operations to ensure data consistency and prevent race conditions. In this article, we will explore the StoreUint64 function, an important part of the sync/atomic package, and provide a detailed example to demonstrate its usage.
What is StoreUint64 Function ?
The StoreUint64 function is part of the “sync/atomic” package in Go, which supplies low-level atomic memory operations. This function atomically sets the value of a uint64 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 StoreUint64(addr *uint64, val uint64)
The function takes a pointer to a uint64 variable addr and a uint64 value val as arguments. It sets the value of addr to val atomically.
Example
To illustrate the usage of the StoreUint64 function, let’s create a simple program simulating concurrent data access. We will create two goroutines: one that sets a shared counter to a specific value using the StoreUint64 function and another that reads and prints the counter value using the atomic.LoadUint64 function.
package main
import (
"fmt"
"sync"
"sync/atomic"
"time"
)
func main() {
var counter uint64 = 0
var wg sync.WaitGroup
// Writer goroutine
wg.Add(1)
go func() {
defer wg.Done()
for i := 0; i < 5; i++ {
atomic.StoreUint64(&counter, uint64(i+1))
fmt.Printf("Writer: Counter 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 counter value is %d\n", atomic.LoadUint64(&counter))
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 counter value using the atomic.StoreUint64 function, ensuring atomicity. Meanwhile, the reader goroutine reads the counter value using the atomic.LoadUint64 function, guaranteeing that it always reads the latest value written by the writer goroutine.
This example demonstrates how the StoreUint64 function can be used to perform atomic write operations on a shared uint64 variable, ensuring data consistency across concurrent threads.
Conclusion
The StoreUint64 function is a valuable utility provided by the sync/atomic package in Go, enabling atomic write operations on uint64 variables. It is particularly useful in concurrent programming when multiple goroutines access shared memory. Using the StoreUint64 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/category/leetcode/
https://pkg.go.dev/net/[email protected]