golang中三种线程安全的MAP

在Go语言中，并发访问map时不需要额外的线程安全机制，因为map本身就是线程不安全的。如果你需要在并发环境下安全地使用map，你可以使用以下三种方法：

1. 使用sync.RWMutex来保护map。
2. 使用sync.Map类型。
3. 使用channel结合range构造并发安全的map。

以下是每种方法的示例代码：

1. 使用sync.RWMutex保护map：

type SafeMap struct {
    sync.RWMutex
    internal map[string]int
}
 
func (sm *SafeMap) Get(key string) (int, bool) {
    sm.RLock()
    defer sm.RUnlock()
    value, ok := sm.internal[key]
    return value, ok
}
 
func (sm *SafeMap) Set(key string, value int) {
    sm.Lock()
    defer sm.Unlock()
    sm.internal[key] = value
}

2. 使用sync.Map：

var sm sync.Map
 
func Get(key string) (value interface{}, loaded bool) {
    return sm.Load(key)
}
 
func Set(key string, value interface{}) {
    sm.Store(key, value)
}

3. 使用channel结合range：

func ConcurrentMap(mapData map[string]int, f func(string, int) int) map[string]int {
    result := make(map[string]int)
    job := make(chan string, len(mapData))
    var wg sync.WaitGroup
 
    go func() {
        for key := range mapData {
            job <- key
        }
        close(job)
    }()
 
    for w := 1; w <= 10; w++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for key := range job {
                result[key] = f(key, mapData[key])
            }
        }()
    }
 
    wg.Wait()
    return result
}

在实际应用中，你应该根据具体场景选择最合适的方法。例如，如果你需要频繁的读写操作，第一种方法可能会因为锁的频繁竞争而影响性能。而第三种方法则更适合于密集型的计算任务。