本文基于go1.22.5编写

1. 简单总结

read好比整个sync.Map的一个“高速缓存”，当goroutine从sync.Map中读数据时，sync.Map会首先查看read这个缓存层是否有用户需要的数据（key是否命中），如果有（key命中），则通过原子操作将数据读取并返回，这是sync.Map推荐的快路径(fast path)，也是sync.Map的读性能极高的原因。

  • 写操作：直接写入dirty（负责写的map）

  • 读操作：先读read（负责读操作的map），没有再读dirty（负责写操作的map）

原理总结：

  1. 通过 read 和 dirty 两个字段实现数据的读写分离，读的数据存在只读字段 read 上，将最新写入的数据则存在 dirty 字段上

  2. 读取时会先查询 read，不存在再查询 dirty，写入时则只写入 dirty

  3. 读取 read 并不需要加锁，而读或写 dirty 则需要加锁

  4. 另外有 misses 字段来统计 read 被穿透的次数（被穿透指需要读 dirty 的情况），超过一定次数则将 dirty 数据更新到 read 中（触发条件：misses=len(dirty)）

2. 核心结构体数据结构

1. sync.Map的数据结构

type Map struct {
	mu Mutex
	read atomic.Pointer[readOnly]
	dirty map[any]*entry
	misses int
}

说明

类型

作用

mu

Mutex

加锁作用。保护后文的dirty字段

read

atomic.Pointer[readOnly]

实际存的是readOnly的原子指针说明类型作用mmap[interface{}]*entry单纯的map结构amendedboolMap.dirty的数据和这里的 m 中的数据不一样的时候，为true。

misses

int

计数作用。每次从read中读失败，则计数+1。

dirty

map[interface{}]*entry

包含最新写入的数据。当misses计数达到一定值，将其赋值给read。

2. readOnly的数据结构

type readOnly struct {
    m       map[any]*entry
    amended bool // true if the dirty map contains some key not in m.
}

说明

类型

作用

m

map[interface{}]*entry

单纯的map结构

amended

bool

sync.Map 的 dirty map 的数据和这里的 m 中的数据不一样的时候，为true

3. entry的数据结构

// An entry is a slot in the map corresponding to a particular key.
type entry struct {
    // p points to the interface{} value stored for the entry.
    //
    // If p == nil, the entry has been deleted, and either m.dirty == nil or
    // m.dirty[key] is e.
    //
    // If p == expunged, the entry has been deleted, m.dirty != nil, and the entry
    // is missing from m.dirty.
    //
    // Otherwise, the entry is valid and recorded in m.read.m[key] and, if m.dirty
    // != nil, in m.dirty[key].
    //
    // An entry can be deleted by atomic replacement with nil: when m.dirty is
    // next created, it will atomically replace nil with expunged and leave
    // m.dirty[key] unset.
    //
    // An entry's associated value can be updated by atomic replacement, provided
    // p != expunged. If p == expunged, an entry's associated value can be updated
    // only after first setting m.dirty[key] = e so that lookups using the dirty
    // map find the entry.
    p atomic.Pointer[any]
}

3. 逻辑解析

1. Load 查询操作

func (m *Map) Load(key any) (value any, ok bool) {
    // 因read只读，线程安全，优先读取
	read := m.loadReadOnly()
	e, ok := read.m[key]
	if !ok && read.amended {
		m.mu.Lock()
        // 双重检查（原因是前文的if判断和加锁非原子的，害怕这中间发生故事）
		read = m.loadReadOnly()
		e, ok = read.m[key]
        // 如果read中还是不存在，并且dirty中有新数据 
		if !ok && read.amended {
			e, ok = m.dirty[key]
			// miss++
			m.missLocked()
		}
		m.mu.Unlock()
	}
	if !ok {
		return nil, false
	}
	return e.load()
}

2. Delete 删除操作

func (m *Map) LoadAndDelete(key any) (value any, loaded bool) {
    read := m.loadReadOnly()
    e, ok := read.m[key]
    if !ok && read.amended {
       m.mu.Lock()
       read = m.loadReadOnly()
       e, ok = read.m[key]
       if !ok && read.amended {
          e, ok = m.dirty[key]
          delete(m.dirty, key)
          // Regardless of whether the entry was present, record a miss: this key
          // will take the slow path until the dirty map is promoted to the read
          // map.
          m.missLocked()
       }
       m.mu.Unlock()
    }
    if ok {
       return e.delete()
    }
    return nil, false
}

// Delete deletes the value for a key.
func (m *Map) Delete(key any) {
    m.LoadAndDelete(key)
}

3. Store 新增/修改操作

func (m *Map) Store(key, value any) {
    _, _ = m.Swap(key, value)
}

func (m *Map) Swap(key, value any) (previous any, loaded bool) {
	read := m.loadReadOnly()
	if e, ok := read.m[key]; ok {
        // 如果read存在这个key，并且没有被标记删除(检查删除在trySwap方法中)，则尝试更新。
		if v, ok := e.trySwap(&value); ok {
			if v == nil {
				return nil, false
			}
			return *v, true
		}
	}

	m.mu.Lock()
	read = m.loadReadOnly()
	if e, ok := read.m[key]; ok {
		if e.unexpungeLocked() {
			// The entry was previously expunged, which implies that there is a
			// non-nil dirty map and this entry is not in it.
			m.dirty[key] = e
		}
		if v := e.swapLocked(&value); v != nil {
			loaded = true
			previous = *v
		}
	} else if e, ok := m.dirty[key]; ok {
		if v := e.swapLocked(&value); v != nil {
			loaded = true
			previous = *v
		}
	} else {
		if !read.amended {
			// We're adding the first new key to the dirty map.
			// Make sure it is allocated and mark the read-only map as incomplete.
			m.dirtyLocked()
			m.read.Store(&readOnly{m: read.m, amended: true})
		}
		m.dirty[key] = newEntry(value)
	}
	m.mu.Unlock()
	return previous, loaded
}

func (e *entry) trySwap(i *any) (*any, bool) {
	for {
		p := e.p.Load()
		if p == expunged {
			return nil, false
		}
		if e.p.CompareAndSwap(p, i) {
			return p, true
		}
	}
}

// 将read中未删除的数据加入到 dirty中
func (m *Map) dirtyLocked() {
	if m.dirty != nil {
		return
	}

	read := m.loadReadOnly()
	m.dirty = make(map[any]*entry, len(read.m))
	for k, e := range read.m {
        // 通过此次操作，dirty中的元素都是未被删除的，可见标记为expunged的元素不在dirty中
		if !e.tryExpungeLocked() {
			m.dirty[k] = e
		}
	}
}

// 判断entry是否被标记删除，并且将标记为nil的entry更新标记为expunge
func (e *entry) tryExpungeLocked() (isExpunged bool) {
	p := e.p.Load()
	for p == nil {
        // 将已经删除标记为nil的数据标记为expunged
		if e.p.CompareAndSwap(nil, expunged) {
			return true
		}
		p = e.p.Load()
	}
	return p == expunged
}

参考：

Golang sync.Map 原理（两个map实现 读写分离、适用读多写少场景）_golang sync.map原理-CSDN博客

由浅入深聊聊Golang的sync.Map今天在技术群中有小伙伴讨论并发安全的东西，其实之前就有写过map相关文章：由浅 - 掘金 (juejin.cn)