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) { //原子操作，加刪除標記  8             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++ 10             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

 

運行結果是：