golang之map并发访问

map 不是并发安全的数据结构，倘若存在并发读写行为，会抛出 fatal error.

具体规则是：

（1）并发读没有问题；

（2）并发读写中的"写"是广义上的，包含写入、更新、删除等操作；

（3）读的时候发现其他 goroutine 在并发写，抛出fatal("concurrent map read and map write")

（4）写的时候发现其他 goroutine 在并发写，抛出fatal("concurrent map writes")

需要关注，此处并发读写会引发 fatal error，是一种比 panic 更严重的错误，无法使用 recover 操作捕获.

recover哪些情况下阻止不了程序崩溃?

来自 Golang map 实现原理

map不是并发安全的!

并发安全也称线程安全,如果在并发中出现了数据的丢失或错乱,就是并发不安全

golang的map不是并发安全的，并发对map读写可能会报fatal error

package main

import (
 "fmt"
 "time"
)

const N = 5

func main() {

 m := make(map[int]int)

 go func() {
  for i := 0; i < N; i++ {
   m[i] = i*10 + 6
  }
 }()

 go func() {
  for i := 0; i < N; i++ {
   fmt.Println(i, m[i])
  }
 }()

 time.Sleep(1e9 * 5)

}

输出为:

上面第一个协程对map写,第二个对map读,

注:如上代码中,调换两个协程的顺序,并不会对结果有影响

当 N 较大如等于1000时,该程序将报错:

fatal error: concurrent map read and map write

goroutine 18 [running]:
runtime.throw(0x10cb62d, 0x21)
 /usr/local/go/src/runtime/panic.go:617 +0x72 fp=0xc00002ef30 sp=0xc00002ef00 pc=0x10281e2
runtime.mapaccess1_fast64(0x10ab340, 0xc000084000, 0x0, 0x0)
 /usr/local/go/src/runtime/map_fast64.go:21 +0x1b3 fp=0xc00002ef58 sp=0xc00002ef30 pc=0x100eac3
main.main.func2(0xc000084000)
 /Users/shuangcui/go/note/map/1.go:22 +0x67 fp=0xc00002efd8 sp=0xc00002ef58 pc=0x1093c37
runtime.goexit()
 /usr/local/go/src/runtime/asm_amd64.s:1337 +0x1 fp=0xc00002efe0 sp=0xc00002efd8 pc=0x1051b51
created by main.main
 /Users/shuangcui/go/note/map/1.go:20 +0x6a

goroutine 1 [sleep]:
runtime.goparkunlock(...)
 /usr/local/go/src/runtime/proc.go:307
time.Sleep(0x12a05f200)
 /usr/local/go/src/runtime/time.go:105 +0x159
main.main()
 /Users/shuangcui/go/note/map/1.go:26 +0x7d

goroutine 17 [runnable]:
main.main.func1(0xc000084000)
 /Users/shuangcui/go/note/map/1.go:16 +0x45
created by main.main
 /Users/shuangcui/go/note/map/1.go:14 +0x48
exit status 2

解决方案:

加锁实现

可以用sync.Mutex (互斥锁)，或者sync.RWMutex(读写锁)来"重构"map,

即定义一个新的结构体,为该结构体实现两个方法,在方法里使用sync包的Mutex或RWMutex来做加锁保证并发安全.

package main

import (
 "fmt"
 "time"
 "sync"
)

const N = 1000

type Cmap struct {
 m    map[int]int
 lock *sync.RWMutex
}

func (c *Cmap) Get(key int) int {
 c.lock.RLock()
 defer c.lock.RUnlock()
 return c.m[key]
}

func (c *Cmap) Set(key, val int) {
 c.lock.Lock()
 defer c.lock.Unlock()
 c.m[key] = val*10 + 8
}

func main() {

 m := make(map[int]int)

 lock := new(sync.RWMutex)

 cm := Cmap{
  m:    m,
  lock: lock,
 }

 go func() {
  for i := 0; i < N; i++ {
   fmt.Println(i, cm.Get(i))
  }
 }()

 go func() {
  for i := 0; i < N; i++ {
   cm.Set(i, i)
  }
 }()

 time.Sleep(1e9 * 5)

}

直接使用sync.Map

从 go1.9 开始,新增了sync.Map,对并发情况下map的安全做了支持,可以对上面代码进行简化:

package main

import (
 "sync"
 "fmt"
 "time"
)

const N = 1000

func main() {
 var m sync.Map

 go func() {
  for i := 0; i < N; i++ {
   v, _ := m.Load(i) //读
   fmt.Println(i, v)
  }
 }()

 go func() {
  for i := 0; i < N; i++ {
   m.Store(i, i*10+4) //写
  }
 }()

 time.Sleep(5 * 1e9)

}

Store为写,Load为读

除去Store和Load两个方法,sync.Map还有几个方法:

删除

func (m *Map) Delete(key interface{})

遍历，类似于js的forEach循环

func (m *Map) Range(f func(key, value interface{}) bool)

存或者取

func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) 这个方法有点绕，举例说下：

package main

import (
 "fmt"
 "sync"
)

func main() {

 var m sync.Map

 actual, loaded := m.LoadOrStore("k1", "v1")
 fmt.Println(actual, loaded) // v1 false

 actual, loaded = m.LoadOrStore("k1", "v1")
 fmt.Println(actual, loaded) // v1 true

 actual, loaded = m.LoadOrStore("k1", "v2")
 fmt.Println(actual, loaded) // v1 true

 actual, loaded = m.LoadOrStore("k2", "v2")
 fmt.Println(actual, loaded) // v2 false

}

LoadOrStore方法其实是先取，如果有key的话就返回，没有再存储，即优先取，没有再存储；

该方法有两个返回值,第一个是键值,第二个是之前有无该键名(bool类型)

(和缓存的做法很类似：先从缓存中取，如果没有则从数据库中读，读回来存入缓存，下次就可以从缓存中取到了。)

本文由mdnice多平台发布