Golang Map 哈希表实现

Map 哈希表实现

1. Map 的顶层结构：hmap

Go 的 Map 不是简单的数组+链表，而是一个精心设计的多层结构。顶层是 hmap（runtime/map.go）：

┌─────────────────────────────────────────────────┐
│                   hmap                           │
├──────────────────┬──────────────────────────────┤
│ count     int    │  Map 中有效键值对数量          │
│ flags     uint8  │  状态标志（并发写检测等）       │
│ B         uint8  │  桶数量 = 2^B                 │
│ noverflow uint16 │  溢出桶的近似数量              │
│ hash0     uint32 │  哈希种子（随机化，防哈希攻击）  │
│ buckets   *bmap  │  指向桶数组的指针              │
│ oldbuckets *bmap │  扩容时指向旧桶数组            │
│ nevacuate uintptr│  渐进迁移进度（已迁移的桶编号） │
│ extra     *mapextra│ 额外信息（预分配的溢出桶等） │
└──────────────────┴──────────────────────────────┘

核心字段解读：

• B：桶数量的以 2 为底的对数。B=5 表示有 32 个桶。Go 用位运算 hash & (2^B - 1) 来定位桶，比取模快。
• hash0：随机种子。每次创建 Map 时，运行时从 /dev/urandom 读取 4 字节作为种子。这使得每次程序运行的哈希值不同，防止攻击者构造哈希碰撞进行 DoS 攻击。
• buckets：指向连续的桶数组，每个桶存放最多 8 个键值对。

2. 桶结构：bmap

每个桶（bmap）是定长的，包含 8 个槽位：

┌──────────────────────────────────────────────────────────┐
│                      bmap (一个桶)                        │
├────────┬────────┬────────┬────────┬────────┬────────┬────┤
│ tophash0│ tophash1│ tophash2│...│ tophash7 │          │  ← 8 个高位哈希
├────────┴────────┴────────┴────┴──────────┴──────────┤
│                      overflow                          │  ← 溢出桶指针
├──────────────────────────────────────────────────────┤
│         key0  key1  key2  ...  key7                   │  ← 8 个 key (连续存储)
├──────────────────────────────────────────────────────┤
│         value0 value1 value2 ... value7               │  ← 8 个 value (连续存储)
└──────────────────────────────────────────────────────┘

为什么 key 和 value 分开存储？

如果每个槽存一个 {key, value} 结构体，不同类型的 key/value 大小不同，会有内存对齐的 padding 浪费。Go 把所有 key 连续放、所有 value 连续放，消除了 key 和 value 之间的 padding。

例如 map[int8]string：

• key 是 1 字节，value 是 16 字节（string header）
• 如果交替存储：[key(1) + padding(7) + value(16)] × 8 = 192 字节
• 分开存储：[8 × 1] + [8 × 16] = 8 + 128 = 136 字节，省了 56 字节

tophash 的作用

tophash 是哈希值的高 8 位，用于快速过滤。查找一个 key 时：

1. 先算出 key 的完整哈希值
2. 取高 8 位得到 tophash
3. 遍历桶中的 8 个 tophash 槽，逐个比较
4. 只有 tophash 匹配的槽才需要做完整 key 比较

这个设计避免了 8 次完整的 key 比较（尤其 key 是长字符串时），只用 8 次字节比较就能过滤掉大部分不匹配的槽。

3. 哈希函数

Go 的运行时哈希函数定义在 runtime/alg.go 中，不同类型使用不同算法：

所有哈希函数最终都和 hash0 种子结合，确保结果随机化。

4. Key 定位算法

给定一个 key，在 Map 中查找的过程：

1. hash = hashfunc(key, hash0)        // 计算 64 位哈希
2. bucket = hash & (2^B - 1)          // 取低位确定桶编号
3. tophash = hash >> (64 - 8)         // 取高 8 位
4. 在 bucket 中遍历 8 个 tophash 槽:
     if tophash[i] == 目标 tophash:
         if key == bucket.key[i]:      // 完整比较
             return bucket.value[i]    // 找到！
5. 如果桶满了且没找到, 沿 overflow 指针找下一个溢出桶
6. 重复 4-5 直到找到或遍历完

哈希值: 0x8B3F2A1C7D5E9F01
                     ^^^^
                     低位 → bucket = 0x1F & mask = 确定哪个桶
        ^^^^
        高位 → tophash = 0x8B → 在桶中快速匹配

5. 哈希冲突处理：拉链法

当两个不同的 key 哈希到同一个桶，且桶已满（8 个槽都用完），Go 会创建一个溢出桶（overflow bucket），挂在当前桶的链表后面：

桶0 ──→ 溢出桶0a ──→ 溢出桶0b ──→ nil

每个桶的 overflow 指针构成单链表。查找时如果主桶没找到，就沿链表继续找。这是经典的拉链法（separate chaining）。

6. Map 的特性

遍历顺序随机化

Go 故意打乱 map 的遍历顺序——每次 range 遍历从随机桶、随机槽位开始。这是为了防止程序员依赖遍历顺序（Go 1.0 前遍历是有序的，导致大量代码依赖顺序，最后不得不加随机化来强制规范）。

Map 值不可寻址

type User struct{ Name string }
m := map[int]User{1: {"Alice"}}
// m[1].Name = "Bob"  // 编译错误: cannot assign to struct field
m[1] = User{Name: "Bob"}  // 必须整体替换

因为 map 可能随时扩容，扩容后元素位置改变，地址无效。所以 Go 不允许取 map 值的地址。

并发写检测

Go 运行时在写 map 时会检查 flags 字段，如果发现并发写，会触发 fatal error: concurrent map writes。这是 fatal error 不是 panic，无法 recover。需要并发安全的 map 请用 sync.Map。

7. 实战验证

下面的代码通过实验验证 Go Map 的行为特性。

package main

import (
    "fmt"
    "sort"
)

func main() {
    // 验证遍历顺序随机化
    m := map[string]int{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
    fmt.Print("第 1 次遍历: ")
    for k := range m { fmt.Printf("%s ", k) }
    fmt.Println()
    fmt.Print("第 2 次遍历: ")
    for k := range m { fmt.Printf("%s ", k) }
    fmt.Println()

    // 验证 map 值不可寻址
    type User struct{ Name string }
    users := map[int]User{1: {"Alice"}}
    users[1] = User{Name: "Bob"} // 必须整体替换
    fmt.Printf("修改后: %v\n", users)

    // 排序后确定性遍历
    keys := make([]int, 0, len(m))
    for k := range m { keys = append(keys, k) }
    sort.Strings(/* ... */)
    // ...
}

8. 知识要点总结

1. hmap + bmap：Map 顶层是 hmap（含 B、hash0、buckets 等字段），底层是 bmap 数组（每桶 8 槽）。
2. key/value 分离存储：所有 key 连续、所有 value 连续，消除 padding 浪费。
3. tophash 快速过滤：哈希高 8 位先比较，匹配后才做完整 key 比较。
4. 拉链法：桶满时用溢出桶链表处理冲突。
5. 哈希随机化：hash0 种子防止哈希碰撞 DoS 攻击。
6. 遍历随机化：Go 故意打乱遍历顺序，防止依赖。
7. 值不可寻址：map 可能扩容导致地址失效，禁止取值地址。
8. 并发写检测：fatal error，无法 recover。