sync.Mutex
In this page:
var mu sync.Mutex
mu.Lock()
defer mu.Unlock()
// critical sectionProtecting Shared State
A sync.Mutex ensures that only one goroutine at a time can execute the code between Lock() and Unlock(), preventing concurrent goroutines from corrupting shared data by modifying it simultaneously.
Example: Protecting Shared State
// Every Go file belongs to a package; main builds an executable
package main
// Import the packages this program uses
import (
"fmt"
"sync"
)
// Define a struct type named Counter
type Counter struct {
mu sync.Mutex
value int
}
// Define the method Increment on type Counter
func (c *Counter) Increment() {
c.mu.Lock()
// defer runs this call when the surrounding function returns
defer c.mu.Unlock()
c.value++
}
// main is where the program starts running
func main() {
// Short declaration: create c and infer the type
c := &Counter{}
// Declare wg with the zero value of its type
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
c.Increment()
}()
}
wg.Wait()
fmt.Println(c.value)
}Login to try C/C++/Java/PHP code in the editor
Always Pair Lock with defer Unlock
Using defer immediately after Lock() guarantees Unlock() runs no matter how the function exits -- including early returns or a panic -- which avoids permanently locking out every other goroutine.
Example: Always Pair Lock with defer Unlock
// Every Go file belongs to a package; main builds an executable
package main
// Import the packages this program uses
import (
"fmt"
"sync"
)
// Define a struct type named SafeMap
type SafeMap struct {
mu sync.Mutex
data map[string]int
}
// Define the method Set on type SafeMap
func (m *SafeMap) Set(key string, value int) {
m.mu.Lock()
// defer runs this call when the surrounding function returns
defer m.mu.Unlock()
m.data[key] = value
}
// main is where the program starts running
func main() {
// Short declaration: create m and infer the type
m := &SafeMap{data: make(map[string]int)}
m.Set("a", 1)
// Print the values followed by a newline
fmt.Println(m.data)
}Login to try C/C++/Java/PHP code in the editor
What Happens Without a Mutex
Without a mutex (or other synchronization), multiple goroutines reading and writing the same variable concurrently produce a data race -- an unpredictable, sometimes silently wrong result that can differ from run to run.
Example: What Happens Without a Mutex
// Every Go file belongs to a package; main builds an executable
package main
// Import the packages this program uses
import (
"fmt"
"sync"
)
// main is where the program starts running
func main() {
// Declare mu with the zero value of its type
var mu sync.Mutex
// Short declaration: create total and infer the type
total := 0
// Declare wg with the zero value of its type
var wg sync.WaitGroup
// Loop: repeat while the condition holds
for i := 0; i < 50; i++ {
wg.Add(1)
// Start this call in a new goroutine (runs concurrently)
go func() {
defer wg.Done()
mu.Lock()
total++
mu.Unlock()
}()
}
wg.Wait()
fmt.Println("total:", total)
}Login to try C/C++/Java/PHP code in the editor
- Forgetting to call Unlock() after Lock(), permanently blocking every other goroutine waiting for that mutex.
- Locking a mutex, then returning early on an error path without unlocking -- always pair Lock() with a deferred Unlock().
- Copying a struct containing a sync.Mutex by value, which duplicates the lock and breaks the mutual exclusion guarantee.
- sync.Mutex provides mutual exclusion: only one goroutine can hold the lock at a time.
- Lock() acquires the mutex (blocking if another goroutine holds it), Unlock() releases it.
- defer mu.Unlock() right after Lock() is the standard way to guarantee release, even on early returns.
- A mutex protects shared data from concurrent, unsynchronized access that would otherwise cause a data race.
Chapter Quiz — Complete all 8 topics to unlock
0/8 topics done
Complete these topics first: