前言
在 Golang 的并发编程实践中，内置的 map 类型在并发读写时会导致 panic，这一设计决策促使开发者需要手动处理并发安全的 Map 结构。今天我们来深入探讨如何实现一个线程安全的 Map，并分析其中的设计考量。
背景
为什么原生 Map 不安全？
Golang 官方在文档中明确说明：Map 不是并发安全的。当多个 goroutine 同时读写同一个 map 时，会触发 runtime 的并发检测机制，导致 panic。
// 错误的并发使用示例
package mainimport ("fmt""runtime""sync""time"
)func main() {// Allocate more logical processors to the program so the// scheduler can run goroutines in parallel.runtime.GOMAXPROPROCS(runtime.NumCPU())// Create a wait group to synchronize the goroutinesvar wg sync.WaitGroup// The shared, non-concurrent-safe mapcounts := make(map[string]int)// Function to be run in multiple goroutinesupdateMap := func(key string) {defer wg.Done()// *** DANGER ***// Multiple goroutines will try to write to the 'counts' map simultaneously herecounts[key]++}// Launch 1000 goroutines to update the map with different keysnumGoroutines := 1000wg.Add(numGoroutines)for i := 0; i < numGoroutines; i++ {go updateMap(fmt.Sprintf("key%d", i%10)) // Use modulo to reuse keys and force collision}// Wait for all goroutines to finish// The program will likely crash with a "fatal error: concurrent map writes" before thiswg.Wait()fmt.Println("This line might not be reached if a panic occurs.")fmt.Printf("Map counts: %v\n", counts)
}
解决
通过 sync.RWMutex 实现读写锁机制：
- 读锁（RLock）：允许多个 goroutine 同时读取
- 写锁（Lock）：只允许一个 goroutine 进行写入
package mainimport ("fmt""sync"
)// SafeMap is a concurrent-safe map protected by a RWMutex.
type SafeMap struct {mu sync.RWMutexm map[string]int
}// NewSafeMap creates a new SafeMap.
func NewSafeMap() *SafeMap {return &SafeMap{m: make(map[string]int),}
}// Get retrieves a value for a key with a read lock.
func (sm *SafeMap) Get(key string) (int, bool) {sm.mu.RLock() // Acquire a read lockdefer sm.mu.RUnlock() // Release the read lock when the function returnsval, ok := sm.m[key]return val, ok
}// Set sets a value for a key with a write lock.
func (sm *SafeMap) Set(key string, value int) {sm.mu.Lock() // Acquire a write lockdefer sm.mu.Unlock() // Release the write lock when the function returnssm.m[key] = value
}// Delete removes a key from the map with a write lock.
func (sm *SafeMap) Delete(key string) {sm.mu.Lock() // Acquire a write lockdefer sm.mu.Unlock() // Release the write lock when the function returnsdelete(sm.m, key)
}func main() {sm := NewSafeMap()var wg sync.WaitGroup// Multiple writersfor i := 0; i < 100; i++ {wg.Add(1)go func(n int) {defer wg.Done()sm.Set(fmt.Sprintf("key%d", n), n)}(i)}// Multiple readersfor i := 0; i < 100; i++ {wg.Add(1)go func(n int) {defer wg.Done()sm.Get(fmt.Sprintf("key%d", n))}(i)}wg.Wait()fmt.Println("Done without race!")
}
延伸
为什么不直接使用标准库？
Golang 1.9+ 提供了官方的并发安全 Map：
import "sync"var m sync.Map// 基本操作
m.Store("key", "value")
value, ok := m.Load("key")
m.Delete("key")// 原子操作
m.LoadOrStore("key", "value")
m.LoadAndDelete("key")
官方sync.Map 适用场景：
- 键值对很少变化，但频繁读取
- 多个 goroutine 读写不同的键
- 不适合频繁写入的场景
总结
并发安全 Map 的实现体现了 Golang 并发编程的核心哲学："通过通信共享内存，而不是通过共享内存进行通信"。
Do not communicate by sharing memory; instead, share memory by communicating.
虽然我们这里使用了共享内存的方式，但通过合理的锁机制，确保了并发安全。
使用自定义SafeMap当你需要：
- 简单的读写操作，代码可读性优先
- 精细控制锁粒度的场景
- 兼容老版本 Go (<1.9)
使用sync.Map当你需要:
- 读多写少的典型场景
- 不同 goroutine 操作不同键
- 不需要频繁遍历所有键值对
记住，没有银弹。根据实际场景选择最合适的并发控制策略，才是优秀工程师的体现。
参考
Go maps in action - The Go Programming Language
The Go Memory Model - The Go Programming Language
Effective Go - The Go Programming Language
sync package - sync - Go Packages
Share Memory By Communicating - The Go Programming Language