Go语言中如何实现等待Map指定Key的值可用？

原代码核心问题分析 #

你当前的Wait方法存在两个关键问题：

1. 解锁后到接收通道信号的间隙中，即使Set已经发送了信号，后续读取m[key]时没有加锁，存在数据竞争；
2. 若多个协程同时等待同一个key，通道的缓冲容量可能不足以容纳所有信号，导致部分协程永久阻塞；更极端的情况是，Set信号刚好发在Wait开始接收之前，虽然能收到信号，但后续无锁读取值的操作依然不安全。

最优实现：基于sync.Cond的方案 #

Go标准库中的sync.Cond专门用于处理"等待-通知"场景，能彻底消除竞态，比手动维护通道更可靠、简洁。以下是完整实现：

import "sync"

type Map struct {
    mu    sync.Mutex
    store map[string]interface{}
    conds map[string]*sync.Cond
}

// 必须调用初始化方法创建实例
func NewMap() *Map {
    return &Map{
        store: make(map[string]interface{}),
        conds: make(map[string]*sync.Cond),
    }
}

// 获取key对应的Cond，不存在则创建
func (m *Map) getCond(key string) *sync.Cond {
    m.mu.Lock()
    defer m.mu.Unlock()

    cond, exists := m.conds[key]
    if !exists {
        // 所有Cond共享同一个互斥锁
        cond = sync.NewCond(&m.mu)
        m.conds[key] = cond
    }
    return cond
}

// 设置key的值，并通知所有等待该key的协程
func (m *Map) Set(key string, value interface{}) {
    m.mu.Lock()
    defer m.mu.Unlock()

    m.store[key] = value
    // 唤醒所有等待该key的协程
    if cond, exists := m.conds[key]; exists {
        cond.Broadcast()
    }
}

// 获取已存在key的值，不存在返回(false)
func (m *Map) Get(key string) (interface{}, bool) {
    m.mu.Lock()
    defer m.mu.Unlock()

    val, exists := m.store[key]
    return val, exists
}

// 等待key的值变为可用，返回对应值
func (m *Map) Wait(key string) interface{} {
    m.mu.Lock()
    defer m.mu.Unlock()

    // 循环检查条件，避免虚假唤醒（sync.Cond的标准用法）
    for {
        if val, exists := m.store[key]; exists {
            return val
        }
        // Wait会自动释放锁，被唤醒后重新获取锁
        m.getCond(key).Wait()
    }
}

方案优势 #

• 无竞态：Wait方法在锁保护下检查条件，等待时自动释放锁，唤醒后重新加锁，彻底消除了原代码中的间隙问题；
• 避免虚假唤醒：通过循环检查条件，符合sync.Cond的最佳实践；
• 高效通知：Broadcast方法一次性唤醒所有等待该key的协程，比手动维护通道更高效；
• 线程安全：所有对存储和Cond的操作都在互斥锁保护下，不存在数据竞争。

原代码的临时修复（不推荐） #

如果一定要基于原通道的思路修改，需要在接收信号后重新加锁读取值，修复后的Wait方法如下：

func (m *Map) Wait(key string) interface{} {
    m.ensureWaitChan(key)

    m.Lock()
    value, ok := m.m[key]
    if ok {
        m.Unlock()
        return value
    }
    // 先持有通道引用再解锁
    ch := m.wait[key]
    m.Unlock()

    <-ch

    // 重新加锁读取值，确保线程安全
    m.Lock()
    defer m.Unlock()
    return m.m[key]
}

但这个方案仍存在通道缓冲溢出、无法处理key被删除等边缘场景，因此更推荐使用sync.Cond的标准实现。

内容的提问来源于stack exchange，提问作者Aerol