Comparing Go performance of Mutex, sync.Map and Channels for concurrent map access for increments

We are facing a simple problem here — we want to have a map, and based on the key, we want to be able to increase/count/set the corresponding value.

That is quite trivial, but what is the best approach? What should we use to prevent race conditions? The infamous Go channels? Simple Mutex locking? Or the sync.Map?

EDIT: Adding “github.com/orcaman/concurrent-map/v2”

How is the relative performance of those? Any guesses?
Here’s the small benchmark application I quickly put together:

package main

import (
 "fmt"
 "strconv"
 "sync"
 "sync/atomic"
 "time"

 cmap "github.com/orcaman/concurrent-map/v2"
)

const (
 iterations = 1000000
 threads    = 10
)

type (
 data struct {
  key int
  val int
 }
)

var (
 cache     = make(map[int]int, 100)
 syncCache sync.Map
 mutex     sync.Mutex
 cm        = cmap.New[int]()
 ch        = make(chan data)
)

func measure(name string, f func()) {
 fmt.Println("Start measuring", name, "...")
 start := time.Now()
 f()
 taken := time.Since(start)
 fmt.Printf("Finished measuring %s, time taken: %v\n\n", name, taken)
}

func exec(meth0d func(i int)) {
 wg := new(sync.WaitGroup)
 wg.Add(threads)
 for t := 0; t < threads; t++ {
  go func() {
   for i := 0; i < iterations; i++ {
    meth0d(i)
   }
   wg.Done()
  }()
 }
 wg.Wait()
}
func main() {
 measure("Mutex", func() {
  exec(func(i int) {
   mutex.Lock()
   cache[i%100000] += 1
   mutex.Unlock()
  })
 })
 measure("concurrent-map", func() {
  exec(func(i int) {
   cm.Upsert(strconv.Itoa(i), 1, func(exist bool, valueInMap int, newValue int) int {
    return newValue + valueInMap
   })
  })
 })
 measure("sync.Map", func() {
  exec(func(i int) {
   elem, _ := syncCache.LoadOrStore(i, new(int32))
   atomic.AddInt32(elem.(*int32), 1)
  })
 })
 measure("Channels", func() {
  go func() {
   for x := range ch {
    cache[x.key] += x.val
   }
  }()
  exec(func(i int) {
   ch <- data{i, 1}
  })
 })
}

And here is the output:

Start measuring Mutex ...
Finished measuring Mutex, time taken: 1.001179811s

Start measuring concurrent-map ...
Finished measuring concurrent-map, time taken: 653.905642ms

Start measuring sync.Map ...
Finished measuring sync.Map, time taken: 3.415632969s

Start measuring Channels ...
Finished measuring Channels, time taken: 3.993437365s

If we increase the number of parallel producers (threads) the results remain relatively the same.

I’d be happy to hear any opinions and also comments about the code or suggestions maybe.

Have a good one! :)