并发安全map —— sync.Map

go原生的map不是线程安全的，在并发读写的时候会触发concurrent map read and map write的panic。 map应该是属于go语言非常高频使用的数据结构。早期go标准库并没有提供线程安全的map，开发者只能自己实现，后面go吸取社区需求提供了线程安全的map——sync.Map。

sync.Map 提供5个如下api：


    func (m *Map) Delete(key interface{})      //删除这个key的value
    func (m *Map) Load(key interface{}) (value interface{}, ok bool) //加载这个key的value
    func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) //原子操作加载，如果没有则存储
    func (m *Map) Range(f func(key, value interface{}) bool) //遍历kv
    func (m *Map) Store(key, value interface{}) //存储

使用sync.Map


package main

import (
    "fmt"
    "sync"
)

func main() {
    sMap := sync.Map{}
    sMap.Store("a","b")
    ret,_:= sMap.Load("a")
    fmt.Printf("ret1 %t \n",ret.(string) == "b" )
    ret,loaded :=sMap.LoadOrStore("a","c")
    fmt.Printf("ret2 %t loaded:%t \n",ret.(string) == "b",loaded )
    ret,loaded =sMap.LoadOrStore("d","c")
    fmt.Printf("loaded %t \n",loaded)
    sMap.Store("e","f")
    sMap.Delete("e")
    sMap.Range(func(key, value interface{}) bool {
        fmt.Printf("k:%s v:%s \n", key.(string),value.(string))
        return true
    })
}


$ go run main.go
ret1 true 
ret2 true loaded:true 
loaded false 
k:a v:b 
k:d v:c

sync.Map底层实现

`sync.Map`的结构体


type Map struct {
    mu Mutex  //互斥锁保护dirty
    read atomic.Value //存读的数据，只读并发安全，存储的数据类型为readOnly
    dirty map[interface{}]*entry //包含最新写入的数据，等misses到阈值会上升为read
    misses int      //计数器，当读read的时候miss了就加+
}


type readOnly struct {
    m  map[interface{}]*entry 
    amended bool //dirty的数据和这里的m中的数据有差异的时候true
}

从结构体上看Map有一定指针数据冗余，但是因为是指针数据，所以冗余的数据量不大。

`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 { //如果没有读到且read的数据和drity数据不一致的时候
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly) //加锁后二次确认
        e, ok = read.m[key]
        if !ok && read.amended { //如果没有读到且 read的数据和drity数据不一致的时候
            e, ok = m.dirty[key]
            m.missLocked()     //misses +1,如果 misses 大于等于 m.dirty 则发送 read的值指向ditry
        }
        m.mu.Unlock()
    }
    if !ok {
        return nil, false
    }
    return e.load()
}

`Store`的源码:


func (m *Map) Store(key, value interface{}) {
    read, _ := m.read.Load().(readOnly)
    if e, ok := read.m[key]; ok && e.tryStore(&value) { //如果在read中找到则尝试更新，tryStore中判断key是否已经被标识删除，如果已经被上传则更新不成功
        return
    }

    m.mu.Lock()
    read, _ = m.read.Load().(readOnly) //同上二次确认
    if e, ok := read.m[key]; ok {
        if e.unexpungeLocked() {// 如果entry被标记expunge，则表明dirty没有key，可添加入dirty，并更新entry。
            m.dirty[key] = e
        }
        e.storeLocked(&value)
    } else if e, ok := m.dirty[key]; ok { //如果dirty存在该key
        e.storeLocked(&value)
    } else { //key不存在
        if !read.amended { //read 和 dirty 一致
          	// 将read中未删除的数据加入到dirty中
            m.dirtyLocked()
             // amended标记为read与dirty不一致，因为即将加入新数据。
            m.read.Store(readOnly{m: read.m, amended: true})
        }
        m.dirty[key] = newEntry(value)
    }
    m.mu.Unlock()
}

`Delete`的源码：


// Delete deletes the value for a key.
func (m *Map) Delete(key interface{}) {
    read, _ := m.read.Load().(readOnly)
    e, ok := read.m[key]
    if !ok && read.amended {   //在read中没有找到且 read和dirty不一致
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly) //加锁二次确认
        e, ok = read.m[key]
        if !ok && read.amended {
            delete(m.dirty, key)  //从dirty中删除
        }
        m.mu.Unlock()
    }
    if ok { //如果key在read中存在
        e.delete() //将指针置为nil，标记删除
    }
}

优缺点

优点: 通过read和dirty冗余的方式实现读写分离，减少锁频率来提高性能。缺点：大量写的时候会导致read读不到数据而进一步加锁读取dirty，同时多次miss的情况下dirty也会频繁升级为read影响性能。因此sync.Map的使用场景应该是读多，写少。

总结

本小节介绍了sync.Map的使用，通过源码的方式了解sync.Map的底层实现，同时介绍了它的优缺点，以及使用场景。

Go一站式编程