• Golang 中 map 探究

    动手点关注 干货不迷路 👆

    简介

    本文主要通过探究在golang 中map的数据结构及源码实现来学习和了解map的特性，共包含map的模型探究、存取、扩容等内容。欢迎大家共同讨论。

    Map 的底层内存模型

    在 golang 的源码中表示 map 的底层 struct 是 hmap，其是 hashmap 的缩写

    1. type hmap struct {
    2.  
    3.    // map中存入元素的个数， golang中调用len(map)的时候直接返回该字段
    4.    count     int
    5.    // 状态标记位，通过与定义的枚举值进行&操作可以判断当前是否处于这种状态
    6.    flags     uint8
    7.    B         uint8  // 2^B 表示bucket的数量， B 表示取hash后多少位来做bucket的分组
    8.    noverflow uint16 // overflow bucket 的数量的近似数
    9.    hash0     uint32 // hash seed （hash 种子） 一般是一个素数
    10.  
    11.    buckets    unsafe.Pointer // 共有2^B个 bucket ，但是如果没有元素存入，这个字段可能为nil
    12.    oldbuckets unsafe.Pointer // 在扩容期间，将旧的bucket数组放在这里， 新buckets会是这个的两倍大
    13.    nevacuate  uintptr        // 表示已经完成扩容迁移的bucket的指针， 地址小于当前指针的bucket已经迁移完成
    14.  
    15.    extra *mapextra // optional fields
    16. }

    B 是 buckets 数组的长度的对数， 即 bucket 数组的长度是 2^B。bucket 的本质上是一个指针，指向了一片内存空间，其指向的 struct 如下所示：

    1. // A bucket for a Go map.
    2. type bmap struct {
    3.    tophash [bucketCnt]uint8
    4. }

    但这只是表面(src/runtime/hashmap.go)的结构，编译期间会给它加料，动态地创建一个新的结构：

    1. type bmap struct {
    2.     topbits  [8]uint8
    3.     keys     [8]keytype
    4.     values   [8]valuetype
    5.     pad      uintptr        // 内存对齐使用，可能不需要
    6.     overflow uintptr        // 当bucket 的8个key 存满了之后
    7. }

    bmap 就是我们常说的“桶”的底层数据结构， 一个桶中可以存放最多 8 个 key/value, map 使用 hash 函数 得到 hash 值决定分配到哪个桶， 然后又会根据 hash 值的高 8 位来寻找放在桶的哪个位置 具体的 map 的组成结构如下图所示：

    e13cf8aeb451c1b351f4a2c987dbdd37.jpeg

    Map 的存与取

    在 map 中存与取本质上都是在进行一个工作， 那就是:

    1. 查询当前 k/v 应该存储的位置。

    2. 赋值/取值， 所以我们理解了 map 中 key 的定位我们就理解了存取。

    底层代码

    1. func mapaccess2(t *maptype, h *hmap, key unsafe.Pointer) (unsafe.Pointer, bool) {
    2.     // map 为空，或者元素数为 0，直接返回未找到
    3.     if h == nil || h.count == 0 {
    4.         return unsafe.Pointer(&zeroVal[0]), false
    5.     }
    6.     // 不支持并发读写
    7.     if h.flags&hashWriting != 0 {
    8.         throw("concurrent map read and map write")
    9.     }
    10.     // 根据hash 函数算出hash值，注意key的类型不同可能使用的hash函数也不同
    11.     hash := t.hasher(key, uintptr(h.hash0))
    12.     // 如果 B = 5，那么结果用二进制表示就是 11111 ， 返回的是B位全1的值
    13.     m := bucketMask(h.B)
    14.     // 根据hash的后B位，定位在bucket数组中的位置
    15.     b := (*bmap)(unsafe.Pointer(uintptr(h.buckets) + (hash&m)*uintptr(t.bucketsize)))
    16.     // 当 h.oldbuckets 非空时，说明 map 发生了扩容
    17.     // 这时候，新的 buckets 里可能还没有老的内容
    18.     // 所以一定要在老的里面找，否则有可能发生“消失”的诡异现象
    19.     if c := h.oldbuckets; c != nil {
    20.         if !h.sameSizeGrow() {
    21.             // 说明之前只有一半的 bucket，需要除 2
    22.             m >>= 1
    23.         }
    24.         oldb := (*bmap)(unsafe.Pointer(uintptr(c) + (hash&m)*uintptr(t.bucketsize)))
    25.         if !evacuated(oldb) {
    26.             b = oldb
    27.         }
    28.     }
    29.     // tophash 取其高 8bit 的值
    30.     top := tophash(hash)
    31.     // 一个 bucket 在存储满 8 个元素后，就再也放不下了，这时候会创建新的 bucket，挂在原来的 bucket 的 overflow 指针成员上
    32.     // 遍历当前bucket的所有链式bucket
    33.     for ; b != nil; b = b.overflow(t) {
    34.         // 在bucket的8个位置上查询
    35.         for i := uintptr(0); i < bucketCnt; i++ {
    36.             // 如果找到了相等的 tophash，那说明就是这个 bucket 了
    37.             if b.tophash[i] != top {
    38.                 continue
    39.             }
    40.             // 根据内存结构定位key的位置
    41.             k := add(unsafe.Pointer(b), dataOffset+i*uintptr(t.keysize))
    42.             if t.indirectkey {
    43.                 k = *((*unsafe.Pointer)(k))
    44.             }
    45.             // 校验找到的key是否匹配
    46.             if t.key.equal(key, k) {
    47.                 // 定位v的位置
    48.                 v := add(unsafe.Pointer(b), dataOffset+bucketCnt*uintptr(t.keysize)+i*uintptr(t.valuesize))
    49.                 if t.indirectvalue {
    50.                     v = *((*unsafe.Pointer)(v))
    51.                 }
    52.                 return v, true
    53.             }
    54.         }
    55.     }
    56.  
    57.     // 所有 bucket 都没有找到，返回零值和 false
    58.     return unsafe.Pointer(&zeroVal[0]), false
    59. }

    寻址过程

    1e53265dc3981c61caed09ddfa089f8e.png d0fa5c6fa8598610ec72e44dd6b32ba0.png

    Map 的扩容

    在 golang 中 map 和 slice 一样都是在初始化时首先申请较小的内存空间，在 map 的不断存入的过程中，动态的进行扩容。扩容共有两种，增量扩容与等量扩容（重新排列并分配内存）。下面我们来了解一下扩容的触发方式：

    1. 负载因子超过阈值，源码里定义的阈值是 6.5。(触发增量扩容)

    2. overflow 的 bucket 数量过多：当 B 小于 15，也就是 bucket 总数 2^B 小于 2^15 时，如果 overflow 的 bucket 数量超过 2^B；当 B >= 15，也就是 bucket 总数 2^B 大于等于 2^15，如果 overflow 的 bucket 数量超过 2^15。（触发等量扩容）

    第一种情况

    58a6a5044926da470305be3a5700a393.jpeg

    第二种情况

    3ed98a18909fd133820deeef93ff37f7.jpeg Map 的有序性

    先说结论，在 golang 中 map 是无序的，准确的说是无法严格保证顺序的， 从上面的源码中我们可以知道，golang 中 map 在扩容后，可能会将部分 key 移至新内存，由于在扩容搬移数据过程中，并未记录原数据位置， 并且在 golang 的数据结构中也并未保存数据的顺序，所以那么这一部分在扩容后实际上就已经是无序的了。

    遍历的过程，其实就是按顺序遍历内存地址，同时按顺序遍历内存地址中的 key。但这时已经是无序的了。但是如果我就一个 map，我保证不会对 map 进行修改删除等操作，那么按理说没有扩容就不会发生改变。但也是因为这样，GO 才在源码中 但是有一个有趣的现象，就算不对 map 进行插入删除等操作致使其扩容，其在遍历过程中仍是无序的。

    1. objMap := make(map[string]int)
    2. for i := 0; i < 5; i++ {
    3.    objMap[strconv.Itoa(i)] = i
    4. }
    5. for i := 0 ; i < 5; i ++ {
    6.    var valStr1, valStr2 string
    7.    for k, v := range objMap {
    8.       fmt.Println(k)
    9.       fmt.Println(v)
    10.       valStr1 += k
    11.    }
    12.    for k, v := range objMap {
    13.       fmt.Println(k)
    14.       fmt.Println(v)
    15.       valStr2 += k
    16.    }
    17.    fmt.Println(valStr1 == valStr2)
    18.    if valStr1 != valStr2 {
    19.       fmt.Println("not equal")
    20.    }
    21. }
    22. fmt.Println("end")

    以上的运行结果是

    996c3ffd2328a0c204ab26f0d2297eb8.png

    不难看出，即使不对 map 进行扩容，在多次遍历时也是无序的，这是因为 golang 官方在设计时故意加上随机的元素，将遍历 map 的顺序随机化，用来防止使用者用来顺序遍历。

    依赖 map 的顺序进行遍历，这是有风险的代码，在 GO 的严格语法规则下，是坚决不提倡的。所以我们在使用 map 时一定要记得其是无序的，不要依赖其顺序。

    Map 的并发

    首先我们大家都知道，在 golang 中 map 并不是一个并发安全的数据结构，当几个 goruotine 同时对一个 map 进行读写操作时，就会出现并发写问题：fatal error: concurrent map writes。但是为什么 map 是不支持并发安全的呢， 主要是因为成本与效益。

    官方答复原因如下：

    • 典型使用场景：map 的典型使用场景是不需要从多个 goroutine 中进行安全访问。

    • 非典型场景（需要原子操作）：map 可能是一些更大的数据结构或已经同步的计算的一部分。

    性能场景考虑：若是只是为少数程序增加安全性，导致 map 所有的操作都要处理 mutex，将会降低大多数程序的性能。同时 golang 提供了并发安全的 sync map。

    1. ， // 不支持并发读写
    2.     if h.flags&hashWriting != 0 {
    3.         throw("concurrent map read and map write")
    4.     }

    但是我们又有疑问了，为什么 golang map 并发冲突了不抛一个 error 出来，或者 panic 掉，而是要让程序 panic，选择让程序 crash 崩溃掉。这里是 golang 官方出于权衡风险和 map 使用复杂度场景考虑的，首先 map 在官方中就明确表示不支持并发读写， 所以并发对 map 进行读写操作本身就是不正确的。

    场景假设一：如果 map 选择在写入或者读取时增加 error 返回值，会导致程序在使用 map 时就无法像现在一样，需要额外的捕获并判断 err。

    场景假设二：如果 map 选择 panic（可被 recover），此时如果出现并发写入数据的场景，就会导致走进 recover 中，如果没有对这种场景进行特殊处理，就会导致 map 中存在脏数据，此时程序在使用 map 时就会引发不可预知的错误，此时排查起来也是很难找到问题的根因的。

    所以 golang 在考虑了这些场景后，选择明确的抛出 crash 崩溃异常，使得风险被提前暴露。可以明确的定位到问题点。综上所述我们在使用 map 时，已经要严格保障其是在单线程内使用的，如果有多线程场景，建议使用 sync map 。

  • 相关阅读:
    uCOS2源码分析1-BSP部分（二）
    Vue框架中的各种指令(续)
    基于PyTorch搭建你的生成对抗性网络
    [附源码]java毕业设计放肆游旅游网
    PyCharm 2023.3.2 关闭时一直显示正在关闭项目
    菜刀，蚁剑，冰蝎，哥斯拉的流量特征
    TIA博途_通过PEEK指令在TP900触摸屏上实现监控所有IO地址的具体方法示例
    线性回归实战---Abalone鲍鱼年龄预测
    C++程序员的成长路径
    R语言ggplot2可视化：可视化条形图（bar plot）、添加主标题、副标题、题注信息（caption）、自定义轴标签文本的角度
  • 原文地址：https://blog.csdn.net/ByteDanceTech/article/details/126314053