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 = 0
}

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(1, "a")
    m.Store(2, "b")
    m.Store(3, "c")
    m.Store(4, "d")

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

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

    //Load
    v, ok = m.Load(1)
    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(1)
    fmt.Println(m.Load(1))

}

4 d
1 a
2 b
3 c
false e
true a
it's an existing key,value is  a
2 b
3 c
4 d
5 e
1 a
<nil> false

 

运行结果是：