Go語言中的sync.Map怎么實現

這篇“Go語言中的sync.Map怎么實現”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“Go語言中的sync.Map怎么實現”文章吧。

1. Map 的基本實現原理

在介紹 sync.Map 的基本實現原理之前，我們需要先了解一下 Go 語言標準庫中的 map 實現原理。在 Go 中，map 是基于哈希表實現的。當我們向 map 中添加元素時，它會根據 key 計算出一個哈希值，然后將這個值映射到一個桶中。如果該桶中已經有了元素，它會遍歷桶中的元素，查找是否已經存在相同的 key，如果存在就更新對應的值，否則就添加一個新的鍵值對。

下面是一個簡單的 map 示例：

m := make(map[string]int)
m["a"] = 1
m["b"] = 2
fmt.Println(m["a"]) // Output: 1

當我們運行這段代碼時，Go 語言會自動幫我們分配一個哈希表和若干個桶，然后將鍵值對添加到對應的桶中。這樣，當我們需要訪問某個 key 對應的值時，Go 語言會根據哈希值快速定位到對應的桶，然后遍歷桶中的元素，查找是否有相同的 key，如果找到了就返回對應的值。

2. sync.Map 的實現原理

sync.Map 是 Go 語言標準庫中的一個并發安全的 Map 實現，它可以在并發情況下安全地讀寫，而不需要加鎖。那么，它是如何實現這種并發安全性的呢？下面我們就來一步步地解析 sync.Map 的實現原理。

2.1 sync.Map 的結構體定義

首先，讓我們來看一下 sync.Map 的結構體定義：

type Map struct {
    mu      sync.Mutex
    read    atomic.Value // readOnly
    dirty   map[interface{}]interface{}
    misses  int
    dirtyLocked uintptr
}

從上面的代碼中可以看出，sync.Map 的實現主要是依賴于一個互斥鎖（sync.Mutex）和兩個 map（read 和 dirty）。其中，read 和 dirty 的作用分別是什么呢？我們先來看一下 read 的定義：

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

可以看到，read 只有一個成員 m，它是一個 map 類型。而 amended 則表示 read 中的鍵值對是否被修改過。接下來，我們來看一下 dirty 的定義：

type dirty struct {
    m       map[interface{}]interface{}
    dirty   map[interface{}]bool
    misses  int
}

和 read 不同的是，dirty 中包含了兩個 map：m 和 dirty。其中，m 存儲了被修改過的鍵值對，而 dirty 則存儲了哪些鍵值對被修改過。

2.2 sync.Map 的讀取實現

在 sync.Map 中，讀取操作非常簡單，直接從 readOnly 中的 m 中查找即可。如果 readOnly 中的鍵值對被修改過，則需要從 dirty 中查找。讀取操作的實現代碼如下：

func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
    read, _ := m.read.Load().(readOnly)
    value, ok = read.m[key]
    if !ok && read.amended {
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly)
        value, ok = read.m[key]
        if !ok && read.amended {
            value, ok = read.m[key]
        }
        m.mu.Unlock()
    }
    return
}

在這段代碼中，我們首先從 readOnly 中的 m 中查找鍵值對。如果鍵值對不存在且 readOnly 中的鍵值對被修改過，則需要獲取互斥鎖，并重新從 readOnly 中查找。如果還是沒有找到，那么就從 dirty 中查找。

2.3 sync.Map 的寫入實現

在 sync.Map 中，寫入操作需要分兩步完成。首先，我們需要判斷 readOnly 中的鍵值對是否被修改過，如果沒有被修改過，則直接將鍵值對添加到 readOnly 中的 m 中即可。否則，我們需要獲取互斥鎖，然后將鍵值對添加到 dirty 中的 m 中，并將對應的鍵添加到 dirty 中的 dirty 中。寫入操作的實現代碼如下：

func (m *Map) Store(key, value interface{}) {
    read, _ := m.read.Load().(readOnly)
    if v, ok := read.m[key]; !ok && !read.amended {
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly)
        if v, ok := read.m[key]; !ok {
            read = readOnly{m: read.m, amended: true}
        }
        read.m[key] = value
        m.read.Store(read)
        m.mu.Unlock()
    } else {
        m.mu.Lock()
        dirty := m.dirtyLocked != 0
        if !dirty {
            m.dirtyLocked = 1
            m.dirty = make(map[interface{}]interface{})
        }
        m.dirty[key] = value
        if !ok {
            m.dirty[key] = value
            m.dirty[key] = true
        }
        if dirty {
            m.mu.Unlock()
            return
        }
        m.read.Store(readOnly{m: read.m, amended: true})
        m.mu.Unlock()
    }
}

在這段代碼中，我們首先從 readOnly 中的 m 中查找鍵值對。如果鍵值對不存在且 readOnly 中的鍵值對沒有被修改過，則需要獲取互斥鎖，并重新從 readOnly 中查找。如果還是沒有找到，則將鍵值對添加到 readOnly 中的 m 中，并將 amended 設置為 true。否則，我們需要獲取互斥鎖，并將鍵值對添加到 dirty 中的 m 中，并將對應的鍵添加到 dirty 中的 dirty 中。如果 dirty 中已經存在該鍵，則只需要更新 dirty 中的鍵值即可。如果 dirty 中沒有該鍵，則需要在 dirty 中添加該鍵，并將該鍵的 dirty 置為 true。

接下來，我們需要判斷 dirty 是否被鎖定。如果 dirty 被鎖定，則直接退出函數。否則，我們需要將 readOnly 中的 amended 設置為 true，并將 readOnly 存儲回 read 中。

2.4 sync.Map 的刪除實現

在 sync.Map 中，刪除操作也需要分兩步完成。首先，我們需要判斷 readOnly 中的鍵值對是否被修改過，如果沒有被修改過，則直接從 readOnly 中的 m 中刪除鍵值對即可。否則，我們需要獲取互斥鎖，然后將鍵添加到 dirty 中的 dirty 中，并將 dirty 中的對應鍵的值設置為 false。刪除操作的實現代碼如下：

func (m *Map) Delete(key interface{}) {
    read, _ := m.read.Load().(readOnly)
    if _, ok := read.m[key]; ok || read.amended {
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly)
        if _, ok := read.m[key]; ok || read.amended {
            if m.dirty == nil {
                m.dirty = make(map[interface{}]interface{})
            }
            m.dirty[key] = false
            m.dirty[key] = true
            m.read.Store(readOnly{m: read.m, amended: true})
        }
        m.mu.Unlock()
    }
}

在這段代碼中，我們首先從 readOnly 中的 m 中查找鍵值對。如果鍵值對存在或者 readOnly 中的鍵值對被修改過，則需要獲取互斥鎖，并重新從 readOnly 中查找。如果還是沒有找到，則將鍵添加到 dirty 中的 dirty 中，并將 dirty 中的對應鍵的值設置為 false。接下來，我們需要判斷 dirty 是否為 nil，如果為 nil，則需要將 dirty 初始化為一個空 map。然后，我們將鍵添加到 dirty 中，并將 dirty 中的對應鍵的值設置為 true。最后，我們將 readOnly 中的 amended 設置為 true，并將 readOnly 存儲回 read 中。

2.5 sync.Map 的遍歷實現

在 sync.Map 中，遍歷操作需要將 readOnly 和 dirty 中的所有鍵值對進行合并，并返回所有未被刪除的鍵值對。遍歷操作的實現代碼如下：

func (m *Map) Range(f func(key, value interface{}) bool) {
    read, _ := m.read.Load().(readOnly)
    if read.amended {
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly)
        if read.amended {
            read = readOnly{
                m: merge(read.m, m.dirty),
            }
            read.amended = false
            m.read.Store(read)
            m.dirty = nil
        }
        m.mu.Unlock()
    }
    for k, v := range read.m {
        if !f(k, v) {
            break
        }
    }
}

func merge(m1, m2 map[interface{}]interface{}) map[interface{}]interface{} {
    if len(m1) == 0 && len(m2) == 0 {
        return nil
    }
    if len(m1) == 0 {
        return m2
    }
    if len(m2) == 0 {
        return m1
    }
    m := make(map[interface{}]interface{})
    for k, v := range m1 {
        m[k] = v
    }
    for k, v := range m2 {
        if _, ok := m[k]; !ok || !v.(bool) {
            m[k] = v
        }
    }
    return m
}

在這段代碼中，我們首先從 readOnly 中獲取所有的鍵值對，并檢查是否有鍵值對被修改過。如果鍵值對被修改過，則需要獲取互斥鎖，并將 readOnly 和 dirty 中的鍵值對合并，然后將合并后的鍵值對存儲回 readOnly 中，并將 dirty 設置為 nil。接下來，我們遍歷 readOnly 中的所有鍵值對，并調用 f 函數來處理鍵值對。如果 f 函數返回 false，則遍歷過程結束。

在這個 Range 函數中，我們還實現了一個名為 merge 的輔助函數，用于合并兩個 map。在合并過程中，我們首先判斷兩個 map 是否為空，如果為空，則直接返回 nil。如果其中一個 map 為空，則返回另一個 map。否則，我們需要將 m1 中的鍵值對全部添加到新的 map 中，并逐個遍歷 m2 中的鍵值對。如果 m2 中的鍵不存在于新的 map 中，或者 m2 中的鍵被刪除，則將其添加到新的 map 中。

以上就是關于“Go語言中的sync.Map怎么實現”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。