Atomic Variable in Golang

In Go language, Atomic Variables are utilized in order to control state. Here, the “sync/atomic” package must be used to use these variables. Moreover, it also prevents race conditions which allows two or more Goroutines to access identical sources. The Atomic counters are available for several goroutines. The main means for managing states in go language is communication over channels.

Example 1:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the usage of
// atomic variable
  
// Including main package
package main
  
// Importing sync/atomic, math/rand,
// fmt, sync, and time
import (
    "fmt"
    "math/rand"
    "sync"
    "sync/atomic"
    "time"
)
  
// Using sync.WaitGroup in order to
// wait for a collection of
// goroutines to finish
var waittime sync.WaitGroup
  
// Declaring atomic variable
var atmvar int32
  
// Defining increment function
func hike(S string) {
  
    // For loop
    for i := 1; i < 7; i++ {
  
        // Calling sleep method with its duration
        // and also calling rand.Intn method
        time.Sleep(time.Duration((rand.Intn(5))) * time.Millisecond)
  
        // Calling AddInt32 method with its
        // parameter
        atomic.AddInt32(&atmvar, 1)
  
        // Prints output
        fmt.Println(S, i, "count ->", atmvar)
    }
  
    // Wait completed
    waittime.Done()
}
  
// Main function
func main() {
  
    // Calling Add method w.r.to
    // waittime variable
    waittime.Add(2)
  
    // Calling hike method with
    // values
    go hike("cat: ")
    go hike("dog: ")
  
    // Calling wait method
    waittime.Wait()
  
    // Prints the value of last count
    fmt.Println("The value of last count is :", atmvar)
}

chevron_right


Output:

dog:  1 count -> 1
cat:  1 count -> 2
dog:  2 count -> 3
dog:  3 count -> 4
cat:  2 count -> 5
cat:  3 count -> 6
cat:  4 count -> 7
cat:  5 count -> 8
cat:  6 count -> 9
dog:  4 count -> 10
dog:  5 count -> 11
dog:  6 count -> 12
The value of last count is : 12

In the above method, the atomic variable is of type int32. Here, rand.Intn() method is used to print random integer until the loop stops. After that, AddInt32 method is used which adds the atomic variable with another int32 number and then returns it in the count.

Example 2:

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to illustrate the usage of
// AfterFunc() function
  
// Including main package
package main
  
// Importing sync/atomic, fmt,
// and sync
import (
    "fmt"
    "sync"
    "sync/atomic"
)
  
// Calling main
func main() {
  
    // Declaring atomic variable
    var atmvar uint32
  
    // Using sync.WaitGroup in order to
    // wait for a collection of
    // goroutines to finish
    var wait sync.WaitGroup
  
    // For loop
    for i := 0; i < 30; i += 2 {
  
        // Calling Add method
        wait.Add(1)
  
        // Calling AddUint32 method under
        // go function
        go func() {
            atomic.AddUint32(&atmvar, 2)
  
            // Wait completed
            wait.Done()
        }()
    }
  
    // Calling wait method
    wait.Wait()
  
    // Prints atomic variables value
    fmt.Println("atmvar:", atmvar)
}

chevron_right


Output:

atmvar: 30

In the above method, the atomic variable is of type uint32. Here, AddUint32() method is used under the for loop which adds its parameters until loop stops and then returns the value of the atomic variable.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.