Go 同步原语:Mutex、RWMutex、WaitGroup、Once

Go 同步原语:Mutex、RWMutex、WaitGroup、Once

Hello,我是小兔大白糖。 读完能在 Channel 与共享内存之间选对 Mutex/RWMutex,并用 WaitGroup/Once 收口生命周期。

估计阅读时间:8 分钟

Mutex、RWMutex、WaitGroup、Once
Mutex、RWMutex、WaitGroup、Once · 点击查看 SVG 原图

1. 概念定义

1.1 Go 同步原语概览

原语用途Java 对应
sync.Mutex互斥锁ReentrantLock
sync.RWMutex读写锁ReadWriteLock
sync.Once单次执行双重检查锁定单例
sync.WaitGroup等待一组任务CountDownLatch
sync.Cond条件变量Object.wait/notify
sync.Map并发安全 mapConcurrentHashMap

2. 语法详解

2.1 sync.Mutex vs Java ReentrantLock

// Go Mutex 使用
var mu sync.Mutex
 
func update() {
    mu.Lock()
    defer mu.Unlock()
 
    // 临界区
    counter++
}
// Java ReentrantLock 等效
private final ReentrantLock lock = new ReentrantLock();
 
public void update() {
    lock.lock();
    try {
        // 临界区
        counter++;
    } finally {
        lock.unlock();
    }
}

2.2 sync.RWMutex vs Java ReadWriteLock

// Go RWMutex - 读多写少场景
var rwmu sync.RWMutex
var data map[string]string
 
func read(key string) string {
    rwmu.RLock()         // 读锁
    defer rwmu.RUnlock()
    return data[key]
}
 
func write(key, value string) {
    rwmu.Lock()          // 写锁
    defer rwmu.Unlock()
    data[key] = value
}
// Java ReadWriteLock 等效
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Map<String, String> data = new HashMap<>();
 
public String read(String key) {
    rwLock.readLock().lock();
    try {
        return data.get(key);
    } finally {
        rwLock.readLock().unlock();
    }
}
 
public void write(String key, String value) {
    rwLock.writeLock().lock();
    try {
        data.put(key, value);
    } finally {
        rwLock.writeLock().unlock();
    }
}

2.3 sync.Once vs Java 单例模式

// Go sync.Once - 线程安全的单次执行
var (
    instance *Config
    once     sync.Once
)
 
func GetConfig() *Config {
    once.Do(func() {
        instance = &Config{}
        instance.init()  // 初始化逻辑
    })
    return instance
}
// Java 双重检查锁定单例
public class Config {
    private static volatile Config instance;
 
    public static Config getInstance() {
        if (instance == null) {
            synchronized (Config.class) {
                if (instance == null) {
                    instance = new Config();
                }
            }
        }
        return instance;
    }
}

2.4 sync.WaitGroup vs Java CountDownLatch

// Go WaitGroup
var wg sync.WaitGroup
 
for i := 0; i < 5; i++ {
    wg.Add(1)
    go func(id int) {
        defer wg.Done()
        process(id)
    }(i)
}
 
wg.Wait()  // 阻塞等待
// Java CountDownLatch
CountDownLatch latch = new CountDownLatch(5);
 
for (int i = 0; i < 5; i++) {
    executor.submit(() -> {
        try {
            process(i);
        } finally {
            latch.countDown();
        }
    });
}
 
latch.await();  // 阻塞等待

3. 项目代码示例

3.1 配置管理(sync.Once)

// ConfigManager 配置管理器
type ConfigManager struct {
    once     sync.Once
    config   *Config
    configMu sync.RWMutex
}
 
// GetConfig 获取配置(线程安全单例)
func (cm *ConfigManager) GetConfig() *Config {
    cm.once.Do(func() {
        cm.config = loadConfig()
    })
 
    cm.configMu.RLock()
    defer cm.configMu.RUnlock()
    return cm.config
}
 
// ReloadConfig 重新加载配置
func (cm *ConfigManager) ReloadConfig() error {
    newConfig, err := loadConfig()
    if err != nil {
        return err
    }
 
    cm.configMu.Lock()
    cm.config = newConfig
    cm.configMu.Unlock()
 
    return nil
}

3.2 计数器统计(sync.Mutex)

// Counter 线程安全计数器
type Counter struct {
    mu    sync.Mutex
    count int64
}
 
// Inc 增加计数
func (c *Counter) Inc() {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count++
}
 
// Get 获取当前计数
func (c *Counter) Get() int64 {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.count
}
 
// BatchIncr 批量增加
func (c *Counter) BatchIncr(n int64) {
    c.mu.Lock()
    defer c.mu.Unlock()
    c.count += n
}

4. 业界应用案例

4.1 蚂蚁金服支付系统

场景:账户余额操作 方案:使用 Mutex 保护账户余额,支持分布式部署 效果:每秒处理 10 万+ 支付请求

4.2 Netflix 分布式缓存

场景:热点数据缓存 方案:使用 RWMutex 保护缓存结构,读操作远多于写操作 效果:缓存读取 QPS 达到百万级别

4.3 腾讯微信支付

场景:交易流水号生成 方案:使用 atomic 计数器 + Mutex 双重保护 效果:分布式环境下生成唯一 ID


5. 业务场景对照

5.1 何时使用哪种同步原语

场景推荐原语原因
保护共享计数器atomic 或 Mutexatomic 更轻量
读多写少的数据RWMutex允许多读互斥写
只执行一次初始化sync.Once最简洁安全
等待多个任务完成WaitGroup专为等待设计
条件等待/通知Cond支持多个等待者

5.2 注意事项

// 错误 1:Mutex 不可重入
var mu sync.Mutex
 
func foo() {
    mu.Lock()
    bar()  // 在持锁时调用也请求锁 - 死锁!
    mu.Unlock()
}
 
func bar() {
    mu.Lock()  // 等待自己持有的锁 - 死锁
    mu.Unlock()
}
 
// 错误 2:RWMutex 死锁
var rwmu sync.RWMutex
 
func write() {
    rwmu.Lock()
    read()  // 在持写锁时请求读锁 - 可能死锁
    rwmu.Unlock()
}
 
func read() {
    rwmu.RLock()  // 等待写锁释放 - 如果有写者排队可能死锁
    rwmu.RUnlock()
}
 
// 正确做法:避免锁嵌套,按固定顺序获取锁

6. 常见问题与解答

Q7: sync.WaitGroup, sync.Once, sync.Mutex/RWMutex 用法 + Java 对比?

答:见上文的语法详解部分。核心区别:

  • WaitGroup 是一次性等待工具,CountDownLatch 可重置
  • Once 保证只执行一次,Java 需要双重检查锁定
  • Mutex 不可重入,ReentrantLock 可重入

Q8: 资深开发角度对比 Go 和 Java?

答:Go 的同步原语更简洁直观,但功能相对基础。Java 的 JUC 包提供了更丰富的并发工具。选择上,Go 适合微服务,Java 适合复杂企业级应用。

Q9: WaitGroup 跟 Java Future 一样?

答:不一样。WaitGroup 等待一组任务完成,类似 CountDownLatch;Future 用于获取异步计算结果。


7. sync.Map 特别说明

7.1 vs Java ConcurrentHashMap

// Go sync.Map - 适合读多写少场景
var m sync.Map
 
// 存储
m.Store("key", "value")
 
// 读取
if val, ok := m.Load("key"); ok {
    fmt.Println(val)
}
 
// 遍历
m.Range(func(key, value interface{}) bool {
    fmt.Println(key, value)
    return true
})
// Java ConcurrentHashMap
Map<String, String> map = new ConcurrentHashMap<>();
 
// 存储
map.put("key", "value");
 
// 读取
String val = map.get("key");
 
// 遍历
map.forEach((key, val) -> System.out.println(key + val));

7.2 性能对比

操作Go sync.MapJava ConcurrentHashMap
读O(1)O(1)
写O(1) 平均O(1) 平均
遍历锁区间无锁(最终一致)
适用场景读 >> 写读写均衡

注意:Go sync.Map 在写多的场景下性能不如 sync.Mutex + map 组合。