如何在嵌套Map上实现高效锁，兼顾Go协程并发性能？

你的代码触发concurrent map read and map write的核心原因有两个：

1. 外层锁持有时间过长：Add方法中锁了整个外层Map直到方法结束，导致所有Add调用串行执行，完全丧失并发能力；
2. 无锁访问外层Map：main函数直接读取m.item[1]，属于无锁读操作，和Add中的写操作并发冲突，触发致命错误。

要高效利用goroutine并发，核心思路是缩小锁的作用范围，只在修改外层Map的临界区加锁，同时保证所有外层Map的访问（读/写）都具备并发安全性。

方案一：手动缩小外层锁粒度，封装Map访问 #

通过仅在写入外层Map的瞬间加锁，避免锁持有时间覆盖后续goroutine启动操作；同时封装外层Map的读方法，保证读操作也加锁。

package main

import (
    "fmt"
    "sync"
)

type Map struct {
    mutex sync.Mutex
    item  map[int]*Item
}

// GetItem 安全读取外层Map的方法，加锁保证并发安全
func (m *Map) GetItem(key int) *Item {
    m.mutex.Lock()
    defer m.mutex.Unlock()
    return m.item[key]
}

func (m *Map) Add(key int) {
    // 先创建内层Item，无需持有外层锁
    item := &Item{value: make(map[int]int)}
    
    // 仅在写入外层Map的临界区加锁，锁范围最小化
    m.mutex.Lock()
    m.item[key] = item
    m.mutex.Unlock()
    
    // 启动goroutine操作内层Item，此时外层锁已释放，不影响其他Add调用
    for j := 0; j < 100; j++ {
        go item.Inc(j)
    }
}

type Item struct {
    mutex sync.Mutex
    value map[int]int
}

func (m *Item) Inc(key int) {
    m.mutex.Lock()
    m.value[key]++
    m.mutex.Unlock()
}

func (m *Item) Value(key int) int {
    m.mutex.Lock()
    defer m.mutex.Unlock()
    return m.value[key]
}

func main() {
    m := Map{item: make(map[int]*Item)}
    var wg sync.WaitGroup

    // 使用WaitGroup替代Sleep，精准等待所有goroutine完成
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            m.Add(i)
        }(i)
    }
    wg.Wait()

    // 通过封装的GetItem方法安全读取外层Map
    item := m.GetItem(1)
    if item != nil {
        fmt.Printf("Item 1 中key=0的值：%d\n", item.Value(0))
        fmt.Printf("Item 1 中key=99的值：%d\n", item.Value(99))
    }
}

方案二：使用sync.Map优化外层Map并发 #

sync.Map是Go标准库专为并发场景设计的Map，无需手动管理锁，内部通过分离读写逻辑优化并发性能，适合键值对动态变化的场景。

package main

import (
    "fmt"
    "sync"
)

type Map struct {
    item sync.Map
}

func (m *Map) Add(key int) {
    item := &Item{value: make(map[int]int)}
    // 使用sync.Map的Store方法安全写入
    m.item.Store(key, item)
    
    for j := 0; j < 100; j++ {
        go item.Inc(j)
    }
}

// GetItem 使用sync.Map的Load方法安全读取
func (m *Map) GetItem(key int) (*Item, bool) {
    val, ok := m.item.Load(key)
    if !ok {
        return nil, false
    }
    return val.(*Item), true
}

type Item struct {
    mutex sync.Mutex
    value map[int]int
}

func (m *Item) Inc(key int) {
    m.mutex.Lock()
    m.value[key]++
    m.mutex.Unlock()
}

func (m *Item) Value(key int) int {
    m.mutex.Lock()
    defer m.mutex.Unlock()
    return m.value[key]
}

func main() {
    m := Map{}
    var wg sync.WaitGroup

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            m.Add(i)
        }(i)
    }
    wg.Wait()

    item, ok := m.GetItem(1)
    if ok {
        fmt.Printf("Item 1 中key=0的值：%d\n", item.Value(0))
        fmt.Printf("Item 1 中key=99的值：%d\n", item.Value(99))
    }
}

• 方案一：适合对锁粒度有精确控制的场景，外层Map结构清晰，适合键类型固定、可预测的业务场景；
• 方案二：代码更简洁，无需手动管理锁，Go标准库优化过的并发逻辑，适合键数量动态变化、并发读写频繁的场景。

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