背景

关于 Go 语言的 Map，有两个需要注意的特性：

recover

后者意味着，只有出现并发读写的问题，服务就会挂掉。

这两个特性可能大家都知道，可即使有这个共识，我还是见过这个问题导致的事故。

事故的大致情况是，一个人封装了map的读写，没有使用锁。另一个人开协程读写 map。而测试环境请求量小，不一定会导致崩溃，于是，这个问题就留到生产环境才出现了。

除了靠开发者自觉和 code review，还能怎么预防这种情况呢？我觉得在单元测试加入并行测试也很重要。

并行单元测试

单元测试默认不是并发的，比如下面的单测，是可以通过的：

func TestConcurrent(t *testing.T) {
    var m = map[string]int{}
    // 写 map
    t.Run("write", func(t *testing.T) {
      for i := 0; i < 10000; i++ {
        m["a"] = 1
      }
    })
    // 读 map
    t.Run("read", func(t *testing.T) {
      for i := 0; i < 10000; i++ {
        _ = m["a"]
      }
    })
}

但是我们的期望是，上面的单测不通过，该如何解决呢？

testing.TParallel-test.count-test.cpu
t.Parallel()
func TestConcurrent(t *testing.T) {
    var m = map[string]int{}
    t.Run("write", func(t *testing.T) {
      // 加上并行
      t.Parallel()
      for i := 0; i < 10000; i++ {
        m["a"] = 1
      }
    })
    t.Run("read", func(t *testing.T) {
      // 加上并行
      t.Parallel()
      for i := 0; i < 10000; i++ {
        _ = m["a"]
      }
    })
}

这次执行就会报错：

fatal error: concurrent map read and map write

支持并发的 Map

让 Map 支持并发读写并不麻烦，常见的做法有：

sync.RWMutex
sync.RWMutex

sync.RWMutex

我们给上面的单测加上锁，这次运行就能通过了。

func TestConcurrent(t *testing.T) {
	var m = map[string]int{}
	//  定义锁，零值就可以使用
	var mu sync.RWMutex
	t.Run("write", func(t *testing.T) {
		t.Parallel()
		for i := 0; i < 10000; i++ {
			// 锁
			mu.Lock()
			m["a"] = 1
			// 解锁
			mu.Unlock()
		}
	})
	t.Run("read", func(t *testing.T) {
		t.Parallel()
		for i := 0; i < 10000; i++ {
			// 锁
			mu.Lock()
			_ = m["a"]
			// 解锁
			mu.Unlock()
		}
	})
}

sync.Map

sync.Map

map[interface{}]interface{}
  • 当同一个 key 的值，写少读多的时候；
  • 但多个 goroutines 读写或修改一系列不同的key的时候。
MutexRWMutex

sync.Map 提供的方法不多，这里列出一些。注意的是，any 是 go 1.18 中 interface{}的别名。

Store，设置 key-value。

func (m *Map) Store(key, value any)

Load, 根据 key 读取 value。

func (m *Map) Load(key any) (value any, ok bool)

Delete，删除某个key。

func (m *Map) Delete(key any)

f
func (m *Map) Range(f func(key, value any) bool)

还有 LoadAndDelete（读后删除）、LoadOrStore（读key，不存在时设置）。

sync.Map
func TestConcurrent(t *testing.T) {
	// 可以使用零值
	var m sync.Map
	t.Run("write", func(t *testing.T) {
		t.Parallel()
		for i := 0; i < 10000; i++ {
			// 写
			m.Store("a", 1)
		}
	})
	t.Run("read", func(t *testing.T) {
		t.Parallel()
		for i := 0; i < 10000; i++ {
			// 读
			v, ok := m.Load("a")
			if ok {
				_ = v.(int)
			}
		}
	})
}

参考

您可能感兴趣的文章: