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

Hello,我是小兔大白糖。 读完能在 Channel 与共享内存之间选对 Mutex/RWMutex,并用 WaitGroup/Once 收口生命周期。
估计阅读时间:8 分钟
1. 概念定义
1.1 Go 同步原语概览
| 原语 | 用途 | Java 对应 |
|---|---|---|
| sync.Mutex | 互斥锁 | ReentrantLock |
| sync.RWMutex | 读写锁 | ReadWriteLock |
| sync.Once | 单次执行 | 双重检查锁定单例 |
| sync.WaitGroup | 等待一组任务 | CountDownLatch |
| sync.Cond | 条件变量 | Object.wait/notify |
| sync.Map | 并发安全 map | ConcurrentHashMap |
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 或 Mutex | atomic 更轻量 |
| 读多写少的数据 | 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.Map | Java ConcurrentHashMap |
|---|---|---|
| 读 | O(1) | O(1) |
| 写 | O(1) 平均 | O(1) 平均 |
| 遍历 | 锁区间 | 无锁(最终一致) |
| 适用场景 | 读 >> 写 | 读写均衡 |
注意:Go sync.Map 在写多的场景下性能不如 sync.Mutex + map 组合。