Learn X By Example
Learn X By Example

    Go by Example: Atomic Counters

    Go by Example : Atomic Counters

    The primary mechanism for managing state in Go is communication over channels. We saw this for example with worker pools . There are a few other options for managing state though. Here we’ll look at using the sync/atomic package for atomic counters accessed by multiple goroutines.

    package main
    import (
    "fmt"
    "sync"
    "sync/atomic"
)
    func main() {

    We’ll use an atomic integer type to represent our (always-positive) counter.

        var ops atomic.Uint64

    A WaitGroup will help us wait for all goroutines to finish their work.

        var wg sync.WaitGroup

    We’ll start 50 goroutines that each increment the counter exactly 1000 times.

        for i := 0; i < 50; i++ {
        wg.Add(1)
            go func() {
            for c := 0; c < 1000; c++ {

    To atomically increment the counter we use Add .

                    ops.Add(1)
            }
                wg.Done()
        }()
    }

    Wait until all the goroutines are done.

        wg.Wait()

    Here no goroutines are writing to ‘ops’, but using Load it’s safe to atomically read a value even while other goroutines are (atomically) updating it.

        fmt.Println("ops:", ops.Load())
}

    We expect to get exactly 50,000 operations. Had we used a non-atomic integer and incremented it with ops++ , we’d likely get a different number, changing between runs, because the goroutines would interfere with each other. Moreover, we’d get data race failures when running with the -race flag.

    $ go run atomic-counters.go
ops: 50000

    Next we’ll look at mutexes, another tool for managing state.

    Next example: Mutexes .

    Prev
    Go by Example: Arrays
    Next
    Go by Example: Base64 Encoding