Sync Primitives (Mutex & WaitGroup)

Low-level synchronization tools: Mutex, RWMutex, WaitGroup, Once, and Pool.

Real-World Analogy (Mental Model)

“`sync.Mutex` is the key to a single-occupancy airplane bathroom. Only one person holds the key; everyone else waits in line until the door unlocks.”

Interactive Mutex vs Data Race Simulator

Thread Safety

Toggle between sync.Mutex protection and unprotected access to see how data races corrupt shared memory:

Protection Mode:

Shared Memory Counter:Target: 100

mu.Lock() -> counter++ -> mu.Unlock()

Execution Log: Select Mutex mode and click "Spawn 100 Goroutines"

Key Concepts & Rules To Remember

`sync.Mutex` (`Lock()` / `Unlock()`) protects shared state against concurrent data races.
`sync.WaitGroup` (`Add()`, `Done()`, `Wait()`) blocks until a group of goroutines finish.
`sync.Pool` reuses memory objects to reduce garbage collection load.

Step-by-Step Code

1. Understanding Sync Primitives (Mutex & WaitGroup)

Low-level synchronization tools: Mutex, RWMutex, WaitGroup, Once, and Pool. In Go, sync primitives (mutex & waitgroup) is designed around clarity and high runtime efficiency.

example.goGo 1.24+

var wg sync.WaitGroup
for i := 0; i < 3; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        fmt.Println("Worker", id, "done")
    }(i)
}
wg.Wait() // Waits for all 3 workers!

Common Beginner Pitfalls & Mistakes

Mistake: Misusing sync primitives (mutex & waitgroup) without understanding its memory or concurrency semantics.

✅ Correct Way: Always follow standard Go idioms and verify with tests.

Self Assessment

Knowledge Check

Verify your understanding with these interactive practice questions.

Quizzes

Quick checks for understanding

Multiple-choice with inline explanations—expand to see why.

What is the primary concept behind Sync Primitives (Mutex & WaitGroup)?

Finished this lesson?

Mark it as complete to track your overall Go mastery.

PreviousSelect

Next Context