详解Go语言如何解决map并发安全问题

func main() {
 //创建map
 m := make(map[int]string)
 //声明一个长度为2的倒计时门闩
 var wg sync.WaitGroup
 wg.Add(2)

 //协程1写
 go func() {
  for true {
   m[0] = "xiaoming"
  }
  wg.Done()
 }()

 //协程2读
 go func() {
  for true {
   _ = m[0]
  }
  wg.Done()

 }()

 wg.Wait()
 fmt.Println("结束")
}

var mu sync.Mutex


func main() {
 //创建map
 m := make(map[int]string)
 
 var wg sync.WaitGroup
 wg.Add(2)

 //协程1上锁后写
 go func() {

  for true {
   mu.Lock()
   m[0] = "xiaoming"
   mu.Unlock()
  }
  wg.Done()
 }()

 //协程2上锁后读
 go func() {
  for true {
   mu.Lock()
   _ = m[0]
   mu.Unlock()
  }
  wg.Done()

 }()

 wg.Wait()
 fmt.Println("结束")
}

func main() {
 //创建sync.Map
 var m sync.Map
 
 
 var wg sync.WaitGroup
 wg.Add(2)

 //协程1并发写
 go func() {

  for true {
   m.Store(1, "xiaoming")
  }
  wg.Done()
 }()

 //协程2并发读
 go func() {
  for true {
   m.Load(1)
  }
  wg.Done()

 }()

 wg.Wait()
 fmt.Println("结束")
}

type Map struct {
 //重量级锁
 mu Mutex
 //read指针，指向一个不可变的key数组
 read atomic.Pointer[readOnly]

 //dirty 指针指向可以进行追加操作的key数组
 dirty map[any]*entry

 //当前map读写未命中次数
 misses int
}

func (m *Map) Store(key, value any) {
 _, _ = m.Swap(key, value)
}

func (m *Map) Swap(key, value any) (previous any, loaded bool) {
 //上read尝试修改
 read := m.loadReadOnly()
 if e, ok := read.m[key]; ok {
  if v, ok := e.trySwap(&value); ok {
   if v == nil {
    return nil, false
   }
   return *v, true
  }
 }
 //上重量级锁和read原子指针加载进行修改
 m.mu.Lock()
 read = m.loadReadOnly()
 if e, ok := read.m[key]; ok {
  if e.unexpungeLocked() {
   
   m.dirty[key] = e
  }
  if v := e.swapLocked(&value); v != nil {
   loaded = true
   previous = *v
  }
 } else if e, ok := m.dirty[key]; ok { //如果在dirty数组发现则上swap锁进行修改
  if v := e.swapLocked(&value); v != nil {
   loaded = true
   previous = *v
  }
 } else {//上述情况都不符合则将amended 标记为true后进行追加
  if !read.amended {
   
   m.dirtyLocked()
   m.read.Store(&readOnly{m: read.m, amended: true})
  }
  m.dirty[key] = newEntry(value)
 }
 //解锁返回
 m.mu.Unlock()
 return previous, loaded
}

func (m *Map) Load(key any) (value any, ok bool) {
 //加载读原子变量
 read := m.loadReadOnly()
 //尝试在read指针下读取
 e, ok := read.m[key]
 //没读取到上mutex锁到dirty下读取，若发现则更新未命中数后返回结果
 if !ok && read.amended {
  m.mu.Lock()
  
  read = m.loadReadOnly()
  e, ok = read.m[key]
  if !ok && read.amended {
   e, ok = m.dirty[key]
   //更新未命中数
   m.missLocked()
  }
  m.mu.Unlock()
 }
 if !ok {
  return nil, false
 }
 return e.load()
}

func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
 //上读锁定位元素
 read := m.loadReadOnly()
 
 e, ok := read.m[key]
 //为命中则上重量级锁到read和dirty下再次查找，找到了则删除，若是在dirty下找到还需要额外更新一下未命中数
 if !ok && read.amended {
  m.mu.Lock()
  read = m.loadReadOnly()
  e, ok = read.m[key]
  if !ok && read.amended {
   e, ok = m.dirty[key]
   delete(m.dirty, key)
   //自增一次未命中数
   m.missLocked()
  }
  m.mu.Unlock()
 }
 if ok {
  return e.delete()
 }
 return nil, false
}

// Delete deletes the value for a key.
func (m *Map) Delete(key any) {
 m.LoadAndDelete(key)
}