Lesson 17 of 20

14 mins read

Mutexes, RWMutex & Atomic Primitives

In Plain English

When channels are overkill for simple shared state, Go standard library provides low-level synchronization primitives: sync.Mutex, sync.RWMutex for read-heavy workloads, and sync/atomic for lock-free hardware atomics.

The Mental Model

"A Mutex is a bathroom key on a heavy wooden block—only one person can hold it and enter at a time. An RWMutex allows 100 people to read a signboard together, but locks everyone out when an editor updates the sign."

Deep Dive: How It Works

sync.Mutex: Mutual exclusion lock. mu.Lock() blocks until previous owner calls mu.Unlock().

sync.RWMutex: Allows multiple simultaneous readers (RLock) or one exclusive writer (Lock).

sync/atomic: Hardware CPU instructions (atomic.Int64) for zero-allocation, lock-free operations.

Syntax Blueprint

var mu sync.Mutex
mu.Lock()
defer mu.Unlock()
sharedCounter++

Acquire lock with mu.Lock(), defer mu.Unlock() immediately, and update shared state.

Core Rules to Remember

Critical Sections: Keep code between Lock() and Unlock() as brief as possible.

Defer Unlock: Always defer mu.Unlock() to prevent permanent deadlocks on early returns or panics.

Never Copy Mutexes: Pass structs containing mutexes by pointer, never by value.

Common Beginner Traps & How to Fix Them

Mistake:Passing a struct containing a sync.Mutex by value into a function.

Why it happens: Copying a mutex copies its internal locked state, breaking synchronization.

How to fix: Pass the struct as a pointer (*SafeStruct).

Pro Tip: Use go test -race to detect data races in your concurrent code automatically during testing.

Live Interactive Example

Hit Run Code to see it live

Thread-Safe Counter with sync.Mutex

Go 1.22 / Runtime

Output Console

Click "Run Code" to view the rendered output.

How it works: 5 goroutines each incremented 100 times. Mutex locks prevented race conditions.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Lock-Free Counter with sync/atomic

Use sync/atomic atomic.Int64 to implement a thread-safe counter.
Spawn 4 goroutines, each calling counter.Add(25).
Wait with sync.WaitGroup and print "Atomic Sum: %d".

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.