Go语言中在map内实现原子计数器的最优方案

你提到的两个核心问题确实是实现这类原子计数器的关键：map的int64元素不可寻址，无法直接使用atomic.AddInt64；而用指针作为值时，初始化操作不是原子性的，必须处理并发安全。下面是两种可行的实现方案：

方案一：用sync.Map配合*int64 #

sync.Map原生提供了原子性的LoadOrStore方法，刚好能解决指针初始化的并发安全问题。不需要额外加锁，就能完成"不存在则创建，存在则复用"的逻辑，之后对指针指向的int64做原子操作即可：

import (
    "sync"
    "sync/atomic"
)

func main() {
    var counter sync.Map

    // 原子递增指定key的计数
    increment := func(key string) {
        // LoadOrStore是原子操作：如果key不存在，就存储新的int64指针；否则返回已有的指针
        val, _ := counter.LoadOrStore(key, new(int64))
        // 对指针指向的值做原子递增
        atomic.AddInt64(val.(*int64), 1)
    }

    // 原子读取指定key的计数
    getCount := func(key string) int64 {
        val, ok := counter.Load(key)
        if !ok {
            return 0
        }
        return atomic.LoadInt64(val.(*int64))
    }

    // 并发测试
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            increment("test_key")
        }()
    }
    wg.Wait()
    println(getCount("test_key")) // 输出1000
}

这种方案适合读多写少的场景，sync.Map的读操作不需要加锁，性能更好。

方案二：普通map加互斥锁配合*int64 #

如果你的场景读写都比较频繁，可以用普通map加互斥锁来控制指针的初始化逻辑，初始化完成后对int64的原子操作不需要再持有锁，尽量缩小锁的范围：

import (
    "sync"
    "sync/atomic"
)

// 封装一个带锁的原子计数器map
type AtomicCounterMap struct {
    mu    sync.Mutex
    count map[string]*int64
}

// 初始化计数器map
func NewAtomicCounterMap() *AtomicCounterMap {
    return &AtomicCounterMap{
        count: make(map[string]*int64),
    }
}

// 原子递增指定key的计数
func (m *AtomicCounterMap) Increment(key string) {
    m.mu.Lock()
    ptr, exists := m.count[key]
    if !exists {
        ptr = new(int64)
        m.count[key] = ptr
    }
    m.mu.Unlock() // 初始化完成后立即释放锁，避免持有锁做原子操作
    atomic.AddInt64(ptr, 1)
}

// 获取指定key的计数
func (m *AtomicCounterMap) Get(key string) int64 {
    m.mu.Lock()
    ptr, exists := m.count[key]
    m.mu.Unlock()
    if !exists {
        return 0
    }
    return atomic.LoadInt64(ptr) // 用原子读取保证值的一致性
}

// 使用示例
func main() {
    counter := NewAtomicCounterMap()
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment("test_key")
        }()
    }
    wg.Wait()
    println(counter.Get("test_key")) // 输出1000
}

这种方案的优势是逻辑直观，在读写频繁的场景下性能比sync.Map更稳定。

注意事项 #

• 为什么不能直接用map[string]int64做原子操作？因为Go的map元素是不可寻址的，map扩容时元素的存储地址会变化，直接取地址会导致后续操作出错，因此语言层面禁止了这种行为。
• 无论用哪种方案，对int64值的操作必须用原子函数（atomic.AddInt64、atomic.LoadInt64等），避免并发读写导致的竞态问题。

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