当前位置：首页 > news >正文

Go语言中的Mutex：并发安全的守护者

news 2026/5/31 7:17:03

Go语言中的Mutex：并发安全的守护者

上周我们线上出了个bug：两个用户同时下单，库存扣成了负数。一查代码，发现是没有加锁导致的竞态条件。

这就是Mutex要解决的问题：保护共享资源，防止竞态条件。

一、为什么需要Mutex

1. 竞态条件

当多个goroutine同时访问共享资源，且至少有一个是写操作时，就会产生竞态条件。

// 危险：竞态条件 var counter int func increment() { counter++ // 不是原子操作！ } // 多个goroutine同时调用increment() for i := 0; i < 1000; i++ { go increment() } // counter的最终值可能不是1000

2. 数据竞争

数据竞争是指两个或多个goroutine同时访问同一变量，且至少有一个是写操作，没有同步措施。

// 数据竞争示例 var data []int func writer() { data = []int{1, 2, 3} // 写 } func reader() { fmt.Println(data) // 读 } // 同时运行会产生数据竞争 go writer() reader()

二、Mutex的基本用法

1. sync.Mutex

type Counter struct { mu sync.Mutex count int } func (c *Counter) Increment() { c.mu.Lock() defer c.mu.Unlock() c.count++ } func (c *Counter) Get() int { c.mu.Lock() defer c.mu.Unlock() return c.count }

2. sync.RWMutex

type Cache struct { mu sync.RWMutex data map[string]string } func (c *Cache) Get(key string) (string, bool) { c.mu.RLock() defer c.mu.RUnlock() value, ok := c.data[key] return value, ok } func (c *Cache) Set(key, value string) { c.mu.Lock() defer c.mu.Unlock() c.data[key] = value }

三、Mutex的实战技巧

1. 细粒度锁

// 不好的做法：一把大锁 type Server struct { mu sync.Mutex users map[string]*User orders map[string]*Order } // 好的做法：细粒度锁 type Server struct { userMu sync.RWMutex users map[string]*User orderMu sync.RWMutex orders map[string]*Order }

2. 锁的顺序

// 避免死锁：始终按相同顺序获取锁 func transfer(from, to *Account, amount int) { // 按地址排序，确保顺序一致 first, second := from, to if from > to { first, second = to, from } first.mu.Lock() defer first.mu.Unlock() second.mu.Lock() defer second.mu.Unlock() from.balance -= amount to.balance += amount }

3. 使用defer释放锁

func process() { mu.Lock() defer mu.Unlock() // 确保锁一定会被释放 // 处理逻辑 if err := doSomething(); err != nil { return // 锁会自动释放 } if err := doAnotherThing(); err != nil { return // 锁会自动释放 } }

四、Mutex的高级用法

1. _try_lock_模式

type TryMutex struct { mu sync.Mutex } func (m *TryMutex) TryLock(timeout time.Duration) bool { done := make(chan struct{}, 1) go func() { m.mu.Lock() done <- struct{}{} }() select { case <-done: return true case <-time.After(timeout): return false } } func (m *TryMutex) Unlock() { m.mu.Unlock() }

2. 锁分段

type ShardedMap struct { shards [16]*Shard } type Shard struct { mu sync.RWMutex data map[string]interface{} } func (m *ShardedMap) getShard(key string) *Shard { hash := fnv32(key) return m.shards[hash%16] } func (m *ShardedMap) Get(key string) (interface{}, bool) { shard := m.getShard(key) shard.mu.RLock() defer shard.mu.RUnlock() value, ok := shard.data[key] return value, ok }

五、Mutex的常见陷阱

1. 忘记解锁

// 错误 func bad() { mu.Lock() doSomething() // 忘记Unlock！ } // 正确 func good() { mu.Lock() defer mu.Unlock() doSomething() }

2. 锁内调用外部函数

// 危险：锁内调用可能阻塞的函数 func dangerous() { mu.Lock() defer mu.Unlock() // 可能阻塞很长时间！ http.Get("http://api.example.com") } // 安全：减少锁的持有时间 func safe() { mu.Lock() data := localData mu.Unlock() http.Post("http://api.example.com", data) }

3. 死锁

// 死锁示例 func deadlock() { mu1.Lock() mu2.Lock() // 如果另一个goroutine先获取了mu2，就会死锁 // ... mu2.Unlock() mu1.Unlock() }

六、Mutex vs Channel

场景	推荐方案
保护共享状态	Mutex
协调goroutine	Channel
简单的计数器	atomic
复杂的同步逻辑	Channel

七、性能优化

1. 减少锁的粒度

// 不好的做法 type BigStruct struct { mu sync.Mutex field1 int field2 string field3 []byte // ... 很多字段 } // 好的做法：按需加锁 type SmallStruct struct { field1 int // 不需要锁 field2 atomic.Int32 // 原子操作 mu sync.Mutex field3 []byte // 需要锁保护 }

2. 使用atomic替代Mutex

// 不好的做法 type Counter struct { mu sync.Mutex count int64 } // 好的做法 type Counter struct { count atomic.Int64 } func (c *Counter) Increment() { c.count.Add(1) }