Problem Statement
A Staff Engineer at Stripe asks: "We have a high-frequency payment counter that increments millions of times per second. Should we use a Mutex, Channels, or Atomics? Explain your reasoning and benchmark the difference."
The Go Proverb
"Share memory by communicating, don't communicate by sharing memory."
But this doesn't mean channels are always the right choice.
Decision Framework
| Use Case | Best Choice | Reason |
|---|---|---|
| Simple counter | atomic.AddInt64 | Hardware instruction, fastest |
| Protecting complex state | sync.Mutex | Clear ownership semantics |
| Coordinating goroutines | Channels | Communication pattern |
| Read-heavy, write-rare | sync.RWMutex | Multiple concurrent readers |
Benchmark Implementation
package main
import (
"sync"
"sync/atomic"
"testing"
)
// Mutex approach
type MutexCounter struct {
mu sync.Mutex
count int64
}
func (c *MutexCounter) Inc() {
c.mu.Lock()
c.count++
c.mu.Unlock()
}
// Atomic approach
type AtomicCounter struct {
count int64
}
func (c *AtomicCounter) Inc() {
atomic.AddInt64(&c.count, 1)
}
// Channel approach
type ChannelCounter struct {
ch chan struct{}
count int64
}
func NewChannelCounter() *ChannelCounter {
c := &ChannelCounter{ch: make(chan struct{}, 100)}
go func() {
for range c.ch {
c.count++
}
}()
return c
}
func (c *ChannelCounter) Inc() {
c.ch <- struct{}{}
}
// Benchmarks
func BenchmarkMutexCounter(b *testing.B) {
c := &MutexCounter{}
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
c.Inc()
}
})
}
func BenchmarkAtomicCounter(b *testing.B) {
c := &AtomicCounter{}
b.RunParallel(func(pb *testing.PB) {
for pb.Next() {
c.Inc()
}
})
}Typical Results
BenchmarkAtomicCounter-8 200000000 8.5 ns/op
BenchmarkMutexCounter-8 50000000 32.0 ns/op
BenchmarkChannelCounter-8 10000000 150.0 ns/opConclusion
For the payment counter scenario: Use atomic operations. They're ~4x faster than Mutex and ~18x faster than channels for simple increments.
Follow-up Questions
- When would channels be the better choice despite being slower?
- What is "False Sharing" and how does it affect atomic counters?
- How do you implement a lock-free data structure?