在 Go 语言中，构造一个并发安全的 map 集合

Map 集合是 Go 中提供的一个 KV 结构的数据类型，对它的操作在实际的开发中应该是非常多的，不过它不是一个线程安全的。

1 、Map 不是线程安全的

编写下面的测试代码：

func TestUnsafeMap(t *testing.T) {  
    // 创建一个线程不安全的map  
    myMap := make(map[int]int)  
  
    // 创建一个WaitGroup用于等待所有goroutine完成  
    var wg sync.WaitGroup  
  
    // 启动多个goroutine并发访问map  
    for i := 0; i < 5; i++ {  
       wg.Add(1)  
       go func(i int) {  
          defer wg.Done()  
          myMap[i] = i * 10                               // 向map中写入数据  
          fmt.Printf("Key: %d, Value: %d\n", i, myMap[i]) // 读取map中的数据  
       }(i)  
    }  
  
    // 等待所有goroutine完成  
    wg.Wait()  
  
    // 检查map中的值是否正确（这一步是为了模拟测试）  
    for i := 0; i < 5; i++ {  
       if myMap[i] != i*10 {  
          t.Errorf("Expected %d but got %d", i*10, myMap[i])  
       }  
    }  
}

在上面的代码中，虽然只是循环了很少的次数，就很容易出现竞争问题，错误信息类似下面的：

=== RUN   TestUnsafeMap
Key: 4, Value: 40
Fatal error: concurrent map writesKey: 0, Value: 0

Key: 2, Value: 20
Key: 1, Value: 10 t

2 、构建线程安全的 Map

在 Go 中，为了实现一个线程安全的 map 操作，可以使用 sync.Map 或者通过互斥锁（sync.Mutex）来实现。下面的示例代码是使用锁来手动实现的：

  
type SaleMap struct {  
    mu sync.Mutex  
    m  map[int]int  
}  
  
func NewSaleMap() *SaleMap {  
    return &SaleMap{m: make(map[int]int)}  
}  
  
func (s *SaleMap) Set(key int, value int) {  
    s.mu.Lock()  
    defer s.mu.Unlock()  
    s.m[key] = value  
}  
  
func (s *SaleMap) Get(key int) (int, bool) {  
    s.mu.Lock()  
    defer s.mu.Unlock()  
    value, ok := s.m[key]  
    return value, ok  
}  

然后编写单测如下：

func TestConcurrentMap(t *testing.T) {  
    // 创建一个线程安全的map  
    safeMap := NewSaleMap()  
    var wg sync.WaitGroup  
    // 启动多个goroutine并发写入和读取数据  
    for i := 0; i < 500000; i++ {  
       wg.Add(1)  
       go func(i int) {  
          defer wg.Done()  
          safeMap.Set(i, i*10) // 向map中写入数据  
       }(i)  
    }  
    // 等待所有goroutine完成  
    wg.Wait()  
  
    // 检查map中的值是否正确（这一步是为了模拟测试）  
    for i := 0; i < 500000; i++ {  
       if value, _ := safeMap.Get(i); value != i*10 {  
          t.Errorf("Expected %d but got %d", i*10, value)  
       }  
    }  
}

这一次，循环了更多次，不会再有并发问题了。

Over!