Golang中如何结合map与atomic/sync包实现并发安全

在Go中实现并发安全的map，仅使用atomic.Value而不使用互斥锁是可行的，但需要遵循不可变数据模式。你的代码存在数据竞争是因为多个goroutine在修改同一个map的底层数据。以下是修正后的示例：

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

type mapFunc struct {
	mapV map[int]int
}

func newMap() mapFunc {
	return mapFunc{
		mapV: make(map[int]int),
	}
}

func main() {
	var wg sync.WaitGroup
	var v atomic.Value
	v.Store(mapFunc{mapV: map[int]int{0: 1, 1: 2}})

	// 更新goroutine
	update := func(key int) {
		for i := 0; i < 100; i++ {
			// 加载当前值
			old := v.Load().(mapFunc)
			
			// 创建新的map副本
			newMap := make(map[int]int, len(old.mapV))
			for k, v := range old.mapV {
				newMap[k] = v
			}
			
			// 修改副本
			newMap[key]++
			
			// 存储新值
			v.Store(mapFunc{mapV: newMap})
		}
	}

	// 启动更新goroutine
	go update(0)
	go update(1)

	// 读取goroutine
	wg.Add(5)
	for i := 0; i < 5; i++ {
		go func() {
			defer wg.Done()
			for j := 0; j < 20; j++ {
				mapX := v.Load().(mapFunc)
				fmt.Printf("Read: %v\n", mapX.mapV)
			}
		}()
	}

	wg.Wait()
	
	// 最终结果
	final := v.Load().(mapFunc)
	fmt.Printf("Final result: %v\n", final.mapV)
}

关键点：

1. 不可变数据：每次修改都创建新的map副本，而不是修改原有map
2. 原子替换：使用atomic.Value.Store()原子地替换整个mapFunc
3. 读取安全：atomic.Value.Load()总是返回完整的、一致的数据快照

对于更复杂的场景，可以使用sync/atomic包中的指针操作：

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
	"unsafe"
)

type ConcurrentMap struct {
	ptr unsafe.Pointer // *map[int]int
}

func NewConcurrentMap() *ConcurrentMap {
	m := make(map[int]int)
	return &ConcurrentMap{
		ptr: unsafe.Pointer(&m),
	}
}

func (c *ConcurrentMap) Load() map[int]int {
	return *(*map[int]int)(atomic.LoadPointer(&c.ptr))
}

func (c *ConcurrentMap) Store(newMap map[int]int) {
	atomic.StorePointer(&c.ptr, unsafe.Pointer(&newMap))
}

func (c *ConcurrentMap) Update(key int, delta int) {
	for {
		oldPtr := atomic.LoadPointer(&c.ptr)
		oldMap := *(*map[int]int)(oldPtr)
		
		// 创建副本
		newMap := make(map[int]int, len(oldMap))
		for k, v := range oldMap {
			newMap[k] = v
		}
		newMap[key] += delta
		
		// CAS操作
		if atomic.CompareAndSwapPointer(&c.ptr, oldPtr, unsafe.Pointer(&newMap)) {
			break
		}
	}
}

func main() {
	cmap := NewConcurrentMap()
	cmap.Store(map[int]int{0: 1, 1: 2})
	
	var wg sync.WaitGroup
	
	// 并发更新
	wg.Add(2)
	go func() {
		defer wg.Done()
		for i := 0; i < 1000; i++ {
			cmap.Update(0, 1)
		}
	}()
	
	go func() {
		defer wg.Done()
		for i := 0; i < 1000; i++ {
			cmap.Update(1, 1)
		}
	}()
	
	wg.Wait()
	
	fmt.Println("Result:", cmap.Load())
}

这种方法通过CompareAndSwap实现了无锁更新，但需要注意：

1. 每次更新都创建新map，内存开销较大
2. 适合读多写少的场景
3. 对于高频写入场景，sync.Map或sync.RWMutex配合普通map通常更高效

sync.Map是标准库提供的并发安全map实现：

package main

import (
	"fmt"
	"sync"
)

func main() {
	var sm sync.Map
	
	// 存储值
	sm.Store("key1", 1)
	sm.Store("key2", 2)
	
	// 加载值
	if val, ok := sm.Load("key1"); ok {
		fmt.Println("key1:", val)
	}
	
	// 原子操作
	sm.LoadOrStore("key3", 3)
	
	// 遍历
	sm.Range(func(key, value interface{}) bool {
		fmt.Printf("%v: %v\n", key, value)
		return true
	})
}

选择方案：

• 读多写少且键类型固定：sync.Map
• 需要完全控制且不介意复制开销：atomic.Value + 不可变数据
• 一般场景：sync.RWMutex + 普通map