Golang:sync.Map

由于map在gorountine 上不是安全的，所以在大量并发读写的时候，会出现错误。

在1.9版的时候golang推出了sync.Map.

sync.Map

通过阅读源码我们发现sync.Map是通过冗余的两个数据结构(read、dirty),实现性能的提升。

为了提升性能，load、delete、store等操作尽量使用只读的read；

为了提高read的key命中概率，只有当read中读取不到的累计miss次数大于等于dirty的长度时，将dirty数据提升为read；

对于数据的删除，采用延迟标记删除法，只有在提升dirty的时候才删除。

数据结构

   type Map struct {
     // 读写dirty时使用的锁
     mu Mutex
     read atomic.Value
     dirty map[interface{}]*entry
     // 从read中读取不到，从dirty读取到数据时，+1
     misses int
 }

 type readOnly struct {
     m  map[interface{}]*entry
     amended bool
 }

 type entry struct {
     //指针类型
     p unsafe.Pointer
 }

Delete

 func (m *Map) Delete(key interface{}) {
     read, _ := m.read.Load().(readOnly)
     e, ok := read.m[key]
     if !ok && read.amended {
         m.mu.Lock()
         read, _ = m.read.Load().(readOnly)
         e, ok = read.m[key]
         if !ok && read.amended { //double check
             delete(m.dirty, key)
         }
         m.mu.Unlock()
     }
     if ok {
         e.delete()
     }
 }

 func (e *entry) delete() (hadValue bool) {
     for {
         p := atomic.LoadPointer(&e.p)
         if p == nil || p == expunged {
             return false
         }
         if atomic.CompareAndSwapPointer(&e.p, p, nil) { //原子操作，加删除标记
             return true
         }
     }
 }

删除时，如果read中没有，就直接从dirty删除。如果read中有，就把read中标记为删除。

Load

 func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
     read, _ := m.read.Load().(readOnly)
     e, ok := read.m[key]
     if !ok && read.amended {
         m.mu.Lock()
         read, _ = m.read.Load().(readOnly)
         e, ok = read.m[key]
         if !ok && read.amended {
             e, ok = m.dirty[key] // read中读取不到，从dirty读，miss++
             m.missLocked()
         }
         m.mu.Unlock()
     }
     if !ok {
         return nil, false
     }
     return e.load()
 }

Load返回存储在映射中的键值（read中读取不到，从dirty读），如果没有值，则返回nil。ok结果指示是否在映射中找到值。

missLocked和Store

 func (m *Map) missLocked() {
     m.misses++
     if m.misses < len(m.dirty) {
         return
     }
     m.read.Store(readOnly{m: m.dirty})
     m.dirty = nil
     m.misses =
 }

 func (m *Map) Store(key, value interface{}) {
     //如果在read 读取到,就原子操作直接对值进行更新
     read, _ := m.read.Load().(readOnly)
     if e, ok := read.m[key]; ok && e.tryStore(&value) {
         return
     }

     //如果未在read 中读取到值或读取到值进行更新时更新失败,则加锁进行后续处理
     m.mu.Lock()
     read, _ = m.read.Load().(readOnly)
     if e, ok := read.m[key]; ok {
         // double check,如果读取到的值处于删除状态,将值写入dirty map中
         if e.unexpungeLocked() {
             m.dirty[key] = e
         }
         // 原子操作更新key对应的值
         e.storeLocked(&value)
     } else if e, ok := m.dirty[key]; ok {
         //如果在dirty map中读取到值，则直接使用原子操作更新值
         e.storeLocked(&value)
     } else {
         //如果dirty map中不含有值，则说明dirty map已经升级为read map,或者第一次进入
         //需要初始化dirty map，并将read map的key添加到新创建的dirty map中．
         if !read.amended {
             m.dirtyLocked()
             m.read.Store(readOnly{m: read.m, amended: true})
         }
         m.dirty[key] = newEntry(value)
     }
     m.mu.Unlock()
 }

一些观点，当有大量并发读写发生的时候，会有很多的miss导致不断的dirty升级。可能会影响效率。

尝试使用sync.Map

 package main

 import (
     "fmt"
     "sync"
 )

 func main() {
     var m sync.Map
     m.Store(, "a")
     m.Store(, "b")
     m.Store(, "c")
     m.Store(, "d")

     m.Range(func(k, v interface{}) bool {
         fmt.Println(k, v)
         return true
     })
     //LoadOrStore
     v, ok := m.LoadOrStore(, "e")
     fmt.Println(ok, v)

     v, ok = m.LoadOrStore(, "bbb")
     fmt.Println(ok, v)

     //Load
     v, ok = m.Load()
     if ok {
         fmt.Println("it's an existing key,value is ", v)
     } else {
         fmt.Println("it's an unknown key")
     }

     m.Range(func(k, v interface{}) bool {
         fmt.Println(k, v)
         return true
     })

     m.Delete()
     fmt.Println(m.Load())

 }

  d
  a
  b
  c
 false e
 true a
 it's an existing key,value is  a
  b
  c
  d
  e
  a
 <nil> false

运行结果是：