Mutex vs RWMutex in Go: when RLock actually helps

1package main
2
3import (
4	"fmt"
5	"sync"
6)
7
8type Config struct {
9	mu    sync.RWMutex
10	flags map[string]bool
11}
12
13func (c *Config) Enabled(name string) bool {
14	c.mu.RLock() // many readers at once
15	defer c.mu.RUnlock()
16	return c.flags[name]
17}
18
19func (c *Config) Set(name string, on bool) {
20	c.mu.Lock() // waits for readers to leave, then holds it alone
21	defer c.mu.Unlock()
22	c.flags[name] = on
23}
24
25func main() {
26	cfg := &Config{flags: map[string]bool{"new-checkout": false}}
27
28	var wg sync.WaitGroup
29	var mu sync.Mutex
30	on := 0
31	for i := range 100 {
32		if i == 50 {
33			cfg.Set("new-checkout", true)
34		}
35		wg.Go(func() {
36			if cfg.Enabled("new-checkout") {
37				mu.Lock()
38				on++
39				mu.Unlock()
40			}
41		})
42	}
43	wg.Wait()
44	fmt.Println("readers that saw the flag on:", on >= 50)
45}

1package cache
2
3import (
4	"sync"
5	"testing"
6)
7
8type locker interface {
9	Lock()
10	Unlock()
11	RLock()
12	RUnlock()
13}
14
15// mutexRW makes a plain Mutex fit the same interface: RLock is just Lock.
16type mutexRW struct{ sync.Mutex }
17
18func (m *mutexRW) RLock()   { m.Lock() }
19func (m *mutexRW) RUnlock() { m.Unlock() }
20
21var data = func() map[int]int {
22	m := make(map[int]int, 1000)
23	for i := range 1000 {
24		m[i] = i
25	}
26	return m
27}()
28
29// bench does writeEvery-1 reads for every write; each read sums 'work' keys.
30func bench(b *testing.B, l locker, writeEvery, work int) {
31	b.RunParallel(func(pb *testing.PB) {
32		i := 0
33		for pb.Next() {
34			i++
35			if i%writeEvery == 0 {
36				l.Lock()
37				data[i%1000] = i
38				l.Unlock()
39				continue
40			}
41			l.RLock()
42			sum := 0
43			for k := range work {
44				sum += data[k]
45			}
46			l.RUnlock()
47			_ = sum
48		}
49	})
50}
51
52func BenchmarkMutexReadHeavy(b *testing.B)   { bench(b, &mutexRW{}, 1000, 100) }
53func BenchmarkRWMutexReadHeavy(b *testing.B) { bench(b, &sync.RWMutex{}, 1000, 100) }
54func BenchmarkMutexTinyRead(b *testing.B)    { bench(b, &mutexRW{}, 1000, 1) }
55func BenchmarkRWMutexTinyRead(b *testing.B)  { bench(b, &sync.RWMutex{}, 1000, 1) }
56func BenchmarkMutexWriteHeavy(b *testing.B)  { bench(b, &mutexRW{}, 2, 100) }
57func BenchmarkRWMutexWriteHeavy(b *testing.B) { bench(b, &sync.RWMutex{}, 2, 100) }

1package main
2
3import (
4	"fmt"
5	"sync"
6	"time"
7)
8
9func main() {
10	var mu sync.RWMutex
11
12	mu.RLock() // A holds a read lock
13	fmt.Println("first RLock: ok")
14
15	go func() { // B wants to write; it must wait for A
16		mu.Lock()
17		fmt.Println("writer: got the lock after the reader left")
18		mu.Unlock()
19	}()
20	time.Sleep(20 * time.Millisecond) // let B start waiting
21
22	// A plain mu.RLock() here would block forever: B waits for A, A waits for B.
23	fmt.Println("second RLock while a writer waits:", mu.TryRLock())
24
25	mu.RUnlock() // A releases; B can now run
26	time.Sleep(20 * time.Millisecond)
27}

1func (c *Cache) Get(key string) string {
2	c.mu.RLock()
3	v, ok := c.m[key]
4	c.mu.RUnlock()
5	if ok {
6		return v
7	}
8
9	c.mu.Lock()
10	defer c.mu.Unlock()
11	if v, ok := c.m[key]; ok { // someone filled it while we were unlocked
12		return v
13	}
14	v = load(key) // slow; while it runs, every reader is blocked
15	c.m[key] = v
16	return v
17}

1package main
2
3import (
4	"fmt"
5	"maps"
6	"sync"
7	"sync/atomic"
8)
9
10type Flags map[string]bool // never modified after it is published
11
12var current atomic.Pointer[Flags]
13
14func enabled(name string) bool {
15	return (*current.Load())[name] // no lock: readers see one whole snapshot
16}
17
18var writeMu sync.Mutex // writers still take turns with each other
19
20func set(name string, on bool) {
21	writeMu.Lock()
22	defer writeMu.Unlock()
23	next := maps.Clone(*current.Load()) // copy, change the copy, publish it
24	next[name] = on
25	current.Store(&next)
26}
27
28func main() {
29	current.Store(&Flags{"dark-mode": false})
30	fmt.Println("before:", enabled("dark-mode"))
31	set("dark-mode", true)
32	fmt.Println("after:", enabled("dark-mode"))
33}