sync.Map实现原理 - 元素码农

发布时间: 2025-04-24 23:09

↑

# sync.Map实现原理

## 简介

sync.Map是Go语言在1.9版本中引入的一种并发安全的map实现，专门为高并发场景设计。与普通map+互斥锁的方案相比，sync.Map在某些场景下具有更好的性能，特别是在读多写少的情况下。

## 为什么需要sync.Map

在Go语言中，内建的map类型不是并发安全的。在多个goroutine同时访问一个map时，如果至少有一个goroutine在进行写操作，就会导致竞态条件，可能引发程序崩溃。传统的解决方案是使用互斥锁（mutex）来保护map的访问：

```go
var m = make(map[string]int)
var mutex sync.Mutex

// 写操作
func store(key string, value int) {
    mutex.Lock()
    defer mutex.Unlock()
    m[key] = value
}

// 读操作
func load(key string) (int, bool) {
    mutex.Lock()
    defer mutex.Unlock()
    val, ok := m[key]
    return val, ok
}
```

这种方式虽然安全，但在高并发场景下性能较差，因为每次操作都会锁住整个map，即使是读操作也会阻塞其他读操作。

## sync.Map的设计原理

sync.Map采用了一种"空间换时间"的策略，其核心设计是使用了两个内部map：

1. **read map**：用于存储可以被多个goroutine并发读取的数据
2. **dirty map**：用于存储最近写入的数据

这种设计基于以下几个关键思想：

- 读操作优先从read map中获取数据，无需加锁
- 只有在read map中找不到数据时，才会加锁并从dirty map中查找
- 写操作会更新dirty map，并在适当时机将dirty map提升为read map

## sync.Map的内部结构

```go
type Map struct {
    mu Mutex
    read atomic.Value // readOnly结构体
    dirty map[interface{}]*entry
    misses int
}

type readOnly struct {
    m       map[interface{}]*entry
    amended bool // 标记dirty map中是否包含read map中没有的key
}

type entry struct {
    p unsafe.Pointer // *interface{}
}
```

- `mu`：互斥锁，保护dirty map的并发访问
- `read`：原子值，存储readOnly结构体，可以无锁访问
- `dirty`：存储最近写入的数据，需要加锁访问
- `misses`：记录从read map中未命中的次数，用于决定何时将dirty map提升为read map

## 主要操作实现

### Load操作

```go
func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
    // 首先从read map中查找，无需加锁
    read, _ := m.read.Load().(readOnly)
    e, ok := read.m[key]
    if !ok && read.amended {
        // 如果read map中没找到，且dirty map中可能有新数据
        m.mu.Lock()
        // 再次检查read map（双重检查锁定）
        read, _ = m.read.Load().(readOnly)
        e, ok = read.m[key]
        if !ok && read.amended {
            // 从dirty map中查找
            e, ok = m.dirty[key]
            // 记录未命中次数
            m.missLocked()
        }
        m.mu.Unlock()
    }
    if !ok {
        return nil, false
    }
    return e.load()
}
```

### Store操作

```go
func (m *Map) Store(key, value interface{}) {
    // 首先尝试在read map中更新
    read, _ := m.read.Load().(readOnly)
    if e, ok := read.m[key]; ok {
        // 如果key已存在于read map中，尝试直接更新
        e.tryStore(&value)
        return
    }
    
    // 需要更新dirty map
    m.mu.Lock()
    read, _ = m.read.Load().(readOnly)
    if e, ok := read.m[key]; ok {
        // 双重检查
        if e.unexpungeLocked() {
            // 如果entry被标记为删除，则恢复并更新值
            m.dirty[key] = e
        }
        e.storeLocked(&value)
    } else if e, ok := m.dirty[key]; ok {
        // 更新dirty map中已有的entry
        e.storeLocked(&value)
    } else {
        // 新key，需要添加到dirty map
        if !read.amended {
            // dirty map为空，需要从read map复制所有未删除的数据
            m.dirtyLocked()
            m.read.Store(readOnly{m: read.m, amended: true})
        }
        m.dirty[key] = newEntry(value)
    }
    m.mu.Unlock()
}
```

### Delete操作

```go
func (m *Map) Delete(key interface{}) {
    // 首先尝试在read map中标记删除
    read, _ := m.read.Load().(readOnly)
    e, ok := read.m[key]
    if !ok && read.amended {
        // 如果read map中没找到，且dirty map中可能有
        m.mu.Lock()
        read, _ = m.read.Load().(readOnly)
        e, ok = read.m[key]
        if !ok && read.amended {
            // 从dirty map中删除
            delete(m.dirty, key)
        }
        m.mu.Unlock()
        return
    }
    if ok {
        // 标记为已删除
        e.delete()
    }
}
```

## 性能优化机制

### 延迟删除

sync.Map不会立即从内存中删除被删除的条目，而是将其标记为已删除（通过将entry的指针设为特殊值nil）。这样可以避免在删除操作中获取互斥锁。

### 动态提升

当从read map中未命中的次数达到一定阈值（与dirty map的大小相关）时，会将dirty map提升为read map，这样可以减少后续读操作的锁竞争。

```go
func (m *Map) missLocked() {
    m.misses++
    if m.misses < len(m.dirty) {
        return
    }
    // 将dirty map提升为read map
    m.read.Store(readOnly{m: m.dirty, amended: false})
    m.dirty = nil
    m.misses = 0
}
```

## 适用场景

sync.Map适用于以下场景：

1. **读多写少**：大量并发读取，相对较少的更新操作
2. **只增不减**：键值对一旦添加就很少删除
3. **键值相对固定**：map中的键不会频繁变化

不适用于：

1. 写操作频繁的场景
2. 需要频繁遍历的场景（Range操作性能较差）

## 使用示例

```go
package main

import (
    "fmt"
    "sync"
)

func main() {
    var m sync.Map
    
    // 写入数据
    m.Store("key1", 100)
    m.Store("key2", 200)
    
    // 读取数据
    value, ok := m.Load("key1")
    if ok {
        fmt.Println("key1:", value)
    }
    
    // 删除数据
    m.Delete("key1")
    
    // 读取或写入
    actual, loaded := m.LoadOrStore("key2", 300)
    fmt.Println("key2:", actual, "已存在:", loaded)
    
    // 遍历所有键值对
    m.Range(func(key, value interface{}) bool {
        fmt.Println(key, ":", value)
        return true // 返回false会停止遍历
    })
}
```

## 总结

sync.Map通过巧妙的双map设计和原子操作，在特定场景下提供了比传统的map+mutex方案更好的并发性能。它的实现充分体现了Go语言对并发编程的支持和优化思想，是学习Go并发编程的重要案例。

然而，sync.Map并非万能的，在选择使用它之前，应该根据实际应用场景进行性能测试，确保它确实能带来性能提升。在某些场景下，分片锁（sharded locks）或其他并发数据结构可能是更好的选择。