Atomic Variable in Golang

Last Updated : 21 Apr, 2020

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:

// 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) 
} 

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:

// 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) 
} 

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.

time.Time.AppendFormat() Function in Golang With Examples

nidhi1352singh

Improve

Article Tags :

Go Language

Atomic Variable in Golang

Similar Reads

Thank You!

What kind of Experience do you want to share?