1.Go语言学习（2）--map的源码底层原理
2.map在golang的底层实现和源码分析
3.golang map 源码解读（8问）
4.Go 基础篇之 Map
5.Go｜map底层实现、扩容规则、源码特性
6.golang之map详解 - 基础数据结构

Go语言学习（2）--map的源码底层原理

       Golang的Map底层是通过HashTable实现的，创建map时实际返回的源码是runtime/map.go中hmap对象的指针。hmap中buckets指向的源码是bucket数组的指针，bucket数组大小由B决定，源码nutch开发项目源码通常为2^B个。源码单个bucket结构体内部不直接定义keys、源码values和overflow，源码而是源码通过指针运算访问。

       在查找、源码插入和删除过程中，源码通过哈希函数将键转换为哈希值，源码然后使用哈希值对bucket进行定位。源码查找时直接访问哈希表中对应的源码bucket，插入和删除操作涉及更新bucket中的键值对。

       Map的扩容机制基于负载因子，负载因子用于衡量冲突情况，定义为bucket数量与键值对数量的比值。当负载因子大于6.5，或者overflow数量超过时，Map会触发扩容。扩容时，新bucket长度为原bucket长度的2倍，旧bucket数据搬迁到新bucket。为了减少一次性搬迁带来的延迟，Go采用逐步搬迁策略，每次访问map时触发搬迁，每次搬迁2个键值对。

       扩容后，新bucket存储新插入的键值对，老bucket中的键值对逐步搬迁到新bucket。搬迁完成后，删除老bucket。搬迁过程中，老bucket中的键值对将位于新bucket的前部，新插入的键值对位于新bucket的后部。

       等量扩容是重新组织bucket，提升bucket的使用率，而不是简单地增加容量。在某些极端场景下，如果键值对集中在少数bucket，可能导致overflow的bucket数量增多，但负载因子不高，无法执行增量搬迁。这时进行一次等量扩容，可以减少overflow的bucket数量，优化访问效率。

map在golang的底层实现和源码分析

       在Golang 1..2版本中，map的底层实现由两个核心结构体——hmap和bmap（此处用桶来描述）——构建。初始化map，如`make(map[k]v, hint)`，会创建一个hmap实例，计划网址源码包含map的所有信息。makemap函数负责创建hmap、计算B值和初始化桶数组。

       Golang map的高效得益于其巧妙的设计：首先，key的hash值的后B位作为桶索引；其次，key的hash值的前8位决定桶内结构体的数组索引，包括tophash、key和value；tophash数组还用于存储标志位，当桶内元素为空时，标志位能快速识别。读写删除操作充分利用了这些设计，包括更新、新增和删除key-value对。

       删除操作涉及到定位key，移除地址空间，更新桶内tophash的标志位。而写操作，虽然mapassign函数返回value地址但不直接写值，实际由编译器生成的汇编指令提高效率。扩容和迁移机制如sameSizeGrow和biggerSizeGrow，针对桶利用率低或桶数组满的情况，通过调整桶结构和数组长度，优化查找效率。

       evacuate函数负责迁移数据到新的桶区域，并清理旧空间。最后，虽然本文未详述，但订阅"后端云"公众号可获取更多关于Golang map底层实现的深入内容。

golang map 源码解读（8问）

       map底层数据结构为hmap，包含以下几个关键部分：

       1. buckets - 指向桶数组的指针，存储键值对。

       2. count - 记录key的数量。

       3. B - 桶的数量的对数值，用于计算增量扩容。

       4. noverflow - 溢出桶的数量，用于等量扩容。

       5. hash0 - hash随机值，增加hash值的随机性，减少碰撞。

       6. oldbuckets - 扩容过程中的旧桶指针，判断桶是否在扩容中。

       7. nevacuate - 扩容进度值，小于此值的已经完成扩容。

       8. flags - 标记位，用于迭代或写操作时检测并发场景。

       每个桶数据结构bmap包含8个key和8个value，以及8个tophash值，用于第一次比对。

       overflow指向下一个桶，桶与桶形成链表存储key-value。

       结构示意图在此。

       map的朔源码014初始化分为3种，具体调用的函数根据map的初始长度确定：

       1. makemap_small - 当长度不大于8时，只创建hmap，不初始化buckets。

       2. makemap - 当长度参数为int时，底层调用makemap。

       3. makemap - 初始化hash0，计算对数B，并初始化buckets。

       map查询底层调用mapaccess1或mapaccess2，前者无key是否存在的bool值，后者有。

       查询过程：计算key的hash值，与低B位取&确定桶位置，获取tophash值，比对tophash，相同则比对key，获得value，否则继续寻找，直至返回0值。

       map新增调用mapassign，步骤包括计算hash值，确定桶位置，比对tophash和key值，插入元素。

       map的扩容有两种情况：当count/B大于6.5时进行增量扩容，容量翻倍，渐进式完成，每次最多2个bucket；当count/B小于6.5且noverflow大于时进行等量扩容，容量不变，但分配新bucket数组。

       map删除元素通过mapdelete实现，查找key，计算hash，找到桶，遍历元素比对tophash和key，找到后置key,value为nil，修改tophash为1。

       map遍历是无序的，依赖mapiterinit和mapiternext，选择一个bucket和offset进行随机遍历。

       在迭代过程中，可以通过修改元素的key,value为nil，设置tophash为1来删除元素，不会影响遍历的顺序。

Go 基础篇之 Map

       Go 语言以其简洁的语法和卓越的性能而闻名，Map 是其提供的一种键值对数据结构。本文将探讨 Map 的基础知识与高级应用。

       1. Map 基础知识

       1.1 什么是 Map

       在 Go 语言中，Map 是一种无序的键值对集合，类似于 Python 的字典、C++ 的 Map 和 Java 的 HashMap。每个元素包含一个独特的php匿名源码键和一个值，值可以重复。

       1.2 声明一个 Map

       使用 make 函数创建 Map，需要提供类型和初始大小。例如：

       go

       make(Map[string]int, )

       1.3 添加元素到 Map 中

       通过赋值操作符添加元素，如：

       go

       m["one"] = 1

       m["two"] = 2

       1.4 Map 中获取元素

       使用下标操作符获取元素，如：

       go

       fmt.Println(m["one"]) // 输出 1

       1.5 遍历 Map

       使用 for 循环遍历 Map，如：

       go

       for k, v := range m {

        fmt.Println(k, v)

       }

       2. Map 高级用法

       2.1 Map 的零值

       未初始化的 Map 是 nil，使用 make 函数初始化，如：

       go

       m := make(Map[string]int)

       2.2 Map 的长度

       使用 len() 函数获取 Map 长度，如：

       go

       fmt.Println(len(m)) // 输出 2

       2.3 Map 的删除

       使用 delete() 函数删除元素，如：

       go

       delete(m, "foo")

       2.4 Map 的并发安全性

       使用 sync.Map 实现并发安全，如：

       go

       m := sync.Map{ }

       m.Store("foo", )

       val, ok := m.Load("foo")

       fmt.Println(val, ok)

       2.5 Map 的值为函数

       Map 值可以是函数，如：

       go

       m := Map[string]func(int, int) int{

        "add": func(x, y int) int { return x + y },

        "sub": func(x, y int) int { return x - y },

       }

       3. 总结

       本文介绍了 Go 语言中 Map 的基础知识和高级应用，包括零值、长度、删除、并发安全性和函数值等。

Go｜map底层实现、扩容规则、特性

       Go语言中的map数据结构底层实现是基于哈希表，其中关键要点包括哈希函数、桶的分配以及扩容规则。哈希表通过hash函数将键值对分布到桶中，Go语言要求桶的数量m必须是2的整数次幂，以确保所有桶均匀被选中，避免空桶问题。负载因子（元素数量除以桶的数量）是衡量map负载状态的指标。

       Go的map底层结构包括指向bmap（哈希表节点）和mapextra（溢出桶信息）的指针。在扩容时，Go采用渐进式策略，每次只迁移2个桶，以减少对性能的影响。当负载因子超过6.5时，会触发翻倍扩容，将桶数量翻倍。等量扩容则在overflow桶过多且负载因子不高时发生，创建与旧桶数量相同的新的桶并重新排列键值对。

       值得注意的是，Go map的特性包括遍历无序，由于语言设计的随机化，range遍历结果的顺序可能会变化，建议按需排序。此外，Go map是非线程安全的，官方推荐在并发场景下使用读写锁，或者考虑使用sync.Map，它为读写操作提供了更高的并发性能，但写入密集型场景可能会降低效率。

golang之map详解 - 基础数据结构

       在面试场景中，常被询问关于HashMap的底层数据结构和运算原理。本文聚焦于Golang中map对象的底层结构与算法，旨在解析map对象的日本漫画源码本质，揭示其高效性能的原因。

       Golang中的map采用链式哈希表实现，底层基于哈希算法，结构包括哈希数组、桶与溢出桶链表。每个桶最多存放8个key-value对。

       链式哈希表实质由链表构成，各链表对应一个“桶”，元素通过哈希函数（即哈希键）定位至特定桶，随后在链表头部插入。

       深入分析map的底层定义，其代码源于Golang开源项目。

       核心概念：桶指针指向桶首地址，利用桶首及偏移量可查询所有桶。每个桶承载对应键值。hmap.B=2，桶数组长度为2^B，即4，元素经过哈希运算后定位至特定桶存储。

       查找流程类似插入过程，桶内元素通过哈希值定位。

       bucket，即哈希桶，实际存储结构包含8对k/v，低8位指示桶位置，高8位指示元素位置。哈希值相同或低位相同元素存储于同一桶。

       哈希冲突时，元素存储于桶内的哈希值高位，便于后续匹配。

       底层创建时，初始化hmap结构体与足够内存空间A。A前段为哈希数组，后段预留供溢出桶使用。hmap.buckets指向数组首地址，hmap.extra.nextOverflow初始指向内存A后段，即首个预留溢出桶。当冲突需使用新桶时，优先从预留桶链表取用，直至用尽，才考虑申请新空间。

       分配溢出桶优先使用预留桶，无需申请新内存。预留桶耗尽则申请新内存。

       相关资源：cnblogs.com/JoZSM/archives/，jianshu.com/p/fe，my.oschina.net/renhc/blog/。

Go同步原语之sync/Map

       在Go语言中，map的并发使用是不安全的，当多个goroutine同时对一个map进行读写操作时，会发生数据竞争问题。通过使用`go`自带的`-race`检测，可以发现存在数据竞争，即`data race`。解决数据竞争问题，常见的方法是加锁。然而，加锁会带来大量的开销，在高并发场景下，锁的争用会导致系统性能下降。因此，Go语言提供了内置的`sync.Map`，它可以解决并发问题。

       `sync.Map`是`sync`包下的一个特殊结构，它对外提供了常用的方法。基本使用示例包括加载、存储和删除数据。`sync.Map`的核心数据结构包括`read`和`dirty`两个map。`sync.Map`的`Load`函数是负责查询和读取map数据的函数，它通过`read`缓存层优先读取数据，提高了读性能。`Store`函数用于更新数据，而`Delete`函数则负责删除Map中的数据。`Range`函数提供了遍历`sync.Map`的方式，保证了在遍历过程中并发读写操作的正确性。

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

       `sync.Map`的`Store`函数用于更新数据，它首先检查`read`缓存层是否有对应key的数据，如果有，则直接更新；如果没有，则需要先删除`read`缓存层的数据，然后通过加锁的方式在`dirty`map中更新数据。`Delete`函数则会从`sync.Map`中删除指定的key及其对应的value。

       `sync.Map`的`Range`函数提供了O(N)的方式遍历`sync.Map`，遍历过程中，如果在`dirty`map中发生了新的写入操作，会将`dirty`map中的状态提升为`read`map的状态，确保遍历的原子性。

       `orcaman/concurrent-map`是一个适用于反复插入和读取新值的库。它通过分片加锁的方式，降低锁的粒度，从而达到最少的锁等待时间，实现并发安全。

       `sync.Map`的设计目的是为了在读多写少的情况下，提供并发安全的同时又不需要锁的开销。然而，在写多读少的情况下，它的性能可能不如常规的`map`。因此，选择合适的并发数据结构取决于具体的应用场景和性能需求。

Go语言map类型的实现机制

       在 Go 语言中，map 类型是一个将键(key)与值(value)关联起来的数据结构。若两个 map 类型的键元素类型以及值元素类型相同，则它们被视为同一类型；反之则为不同类型。值得注意的是，map 类型对值类型无限制，但键类型需支持“==”与“!=”两种比较操作符。

       在 Go 语言中，函数类型、map 类型本身及切片仅支持与 nil 的比较，而不支持同类型变量间的比较。如尝试进行函数类型、map 类型或切片类型作为键的比较，Go 编译器将报错。

       map 的创建与操作需遵循一定的规则。创建 map 时，键值对的定义遵循键类型与值类型的一致性要求。操作 map 包括插入、删除与查找键值对，以及遍历键值对。map 的遍历通常通过迭代器实现，遍历过程遵循键的唯一性要求。遍历结束条件为迭代器无更多键可迭代。

       在遍历 map 的过程中，对键的处理通常涉及键的访问与使用。若 map 的键类型为自定义类型，需提供有效的比较方法以确保 map 的键唯一性。

       最后，为加深理解，可进行相关练习，如找出给定字符串中不重复字符的最长子串。对于此问题，可利用 map 来记录字符出现的位置，通过遍历字符串并更新 map 来找出最长子串。

       在处理字符串时，使用“rune”作为字符类型更为合适。在 Go 语言中，"rune" 类似于 char，用于表示单个字符。

       总结，学习 Go 语言 map 类型的关键在于理解其键与值的类型约束、创建与操作方法，以及如何通过 map 提升代码效率与可维护性。希望上述内容能帮助你更深入地掌握 Go 语言中的 map 类型。

三万字带你认识 Go 底层 map 的实现

       map在Go语言中是一种基础数据结构，广泛应用于日常开发。其设计遵循“数组+链表”的通用思路，但Go语言在具体实现上有着独特的设计。本文将带你深入了解Go语言中map的底层实现，包括数据结构设计、性能优化策略以及关键操作的内部实现。

       在Go语言的map中，数据存储在数组形式的桶(bucket)中，每个桶最多容纳8对键值对。哈希值的低位用于选择桶，而高位则用于在独立的桶中区分键。这种设计有助于高效地处理冲突和实现快速访问。

       源码位于src/runtime/map.go，展示了map的内部结构和操作。在该文件中，定义了桶和map的内存模型，桶的内存结构示例如下。每个桶的前7-8位未被使用，用于存储键值对，避免了不必要的内存填充。在桶的末尾，还有一个overflow指针，用于连接超过桶容量的键值对，以构建额外的桶。

       初始化map有两种方式，根据是否指定初始化大小和hint值，调用不同的函数进行分配。对于不指定大小或hint值小于8的情况，使用make_small函数直接在堆上分配。当hint值大于8时，调用makemap函数进行初始化。

       插入操作的核心是找到目标键值对的内存地址，并通过该地址进行赋值。在实现中，没有直接将值写入内存，而是返回值在内存中的对应地址，以便后续进行赋值操作。同时，当桶达到容量上限时，会创建新的溢出桶来容纳多余的数据。

       查询操作通过遍历桶来实现，找到对应的键值对。对于查询逻辑的优化，Go语言提供了不同的函数实现，如mapaccess1、mapaccess2和mapaccessK等，它们在不同场景下提供高效的关键字查找和值获取。

       当map需要扩容时，Go语言会根据装载因子进行决策，以保持性能和内存使用之间的平衡。扩容操作涉及到数据搬移，通过hashGrow()和growWork()函数实现。增量扩容增加桶的数量，而等量扩容则通过重新排列元素提高桶的利用率。

       删除操作在Go语言中同样高效，利用map的内部机制快速完成。迭代map时，可以使用特定的函数遍历键值对，实现对数据的访问和操作。

       通过深入分析Go语言中map的实现，我们可以看到Go开发者在设计时的巧妙和全面考虑，不仅关注内存效率，还考虑到数据结构在不同情况下的复用和性能优化。这种设计思想不仅体现在map自身，也对后续的缓存库等开发产生了深远的影响。

       综上所述，Go语言中map的底层实现展示了高效、灵活和强大的设计原则，为开发者提供了强大的工具，同时也启发了其他数据结构和库的设计。了解这些细节有助于我们更深入地掌握Go语言的特性，并在实际开发中做出更优的选择。

Go实例讲解，并发编程-map并发读写的线程安全性问题

       先上实例代码，后面再来详细讲解。

       /** * 并发编程，map的线程安全性问题，使用互斥锁的方式 */ package main import ( "sync" "time" "fmt" ) var data map[int]int = make(map[int]int) var wgMap sync.WaitGroup = sync.WaitGroup{ } var muMap sync.Mutex = sync.Mutex{ } func main() { // 并发启动的协程数量 max := wgMap.Add(max) time1 := time.Now().UnixNano() for i := 0; i < max; i++ { go modifySafe(i) } wgMap.Wait() time2 := time.Now().UnixNano() fmt.Printf("data len=%d, time=%d", len(data), (time2-time1)/) } // 线程安全的方法，增加了互斥锁 func modifySafe(i int) { muMap.Lock() data[i] = i muMap.Unlock() wgMap.Done() }

       上面的代码中 var data map[int]int 是一个key和value都是int类型的map，启动的协程并发执行时，也只是非常简单的对 data[i]=i 这样的一个赋值操作。

       主程序发起1w个并发，不断对map中不同的key进行赋值操作。

       在不安全的情况下，我们直接就看到一个panic异常信息，程序是无法正常执行完成的，如下：

       fatal error: concurrent map writes goroutine [running]: runtime.throw(0x4d6e, 0x) C:/Go/src/runtime/panic.go: +0x9c fp=0xcbf sp=0xcbf pc=0xac runtime.mapassign_fast(0x4ba4c0, 0xce, 0xc, 0x0) C:/Go/src/runtime/hashmap_fast.go: +0x3d9 fp=0xcbfa8 sp=0xcbf pc=0xbed9 main.modifyNotSafe(0xc) mainMap.go: +0x4a fp=0xcbfd8 sp=0xcbfa8 pc=0x4a1f1a runtime.goexit() C:/Go/src/runtime/asm_amd.s: +0x1 fp=0xcbfe0 sp=0xcbfd8 pc=0xcc1 created by main.main mainMap.go: +0x

       对比之前《 Go实例讲解，并发编程-slice并发读写的线程安全性问题》，slice的数据结构在不安全的并发执行中是不会报错的，只是数据可能会出现丢失。

       而这里的map的数据结构，是直接报错，所以在使用中就必须认真对待，否则整个程序是无法继续执行的。

       所以也看出来，Go在对待线程安全性问题方面，对slice还是更加宽容的，对map则更加严格，这也是在并发编程时对我们提出了基本的要求。

       将上面的代码稍微做些修改，对 data[i]=i 的前后增加上 muMap.Lock() 和 muMap.Unlock() ，也就保证了多线程并行的情况下，遇到冲突时有互斥锁的保证，避免出现线程安全性问题。

       关于为什么会出现线程安全性问题，这里就不再详细讲解了，大家可以参考之前的两篇文章《 Go实例讲解，并发编程-slice并发读写的线程安全性问题》和《 Go实例讲解，并发编程-数字递增的线程安全性问题》。

       这里，我们再来探讨一个问题，如何保证map的线程安全性？

       上面我们是通过 muMap 这个互斥锁来保证的。

       而Go语言有一个概念：“不要通过共享内存来进行通信，而应该通过通信来共享内存”，也就是利用channel来保证线程安全性。

       那么，这又要怎么来做呢？下面是实例代码：

       /** * 并发编程，map的线程安全性问题，使用channel的方式 */ package main import ( "time" "fmt" ) var dataCh map[int]int = make(map[int]int) var chMap chan int = make(chan int) func main() { // 并发启动的协程数量 max := time1 := time.Now().UnixNano() for i := 0; i < max; i++ { go modifyByChan(i) } // 处理channel的服务 chanServ(max) time2 := time.Now().UnixNano() fmt.Printf("data len=%d, time=%d", len(dataCh), (time2-time1)/) } func modifyByChan(i int) { chMap <- i } // 专门处理chMap的服务程序 func chanServ(max int) { for { i := <- chMap dataCh[i] = i if len(dataCh) == max { return } } }

       数据填充的方式我们还是用1w个协程来做，只不过使用了chMap这个channel来做队列。

       然后在 chanServ 函数中启动一个服务，专门来消费chMap这个队列，然后把数据给map赋值 dataCh[i]=i 。

       从上面简单的对比中，我们还看不出太多的区别，我们还是可以得出下面一些

       1 通过channel的方式，其实就是通过队列把并发执行的数据读写改成了串行化，以避免线程安全性问题；

       2 多个协程交互的时候，可以通过依赖同一个 channel对象来进行数据的读写和传递，而不需要共享变量，可以参考之前的文章《 Go实例讲解，利用channel实现协程的互动-会聊天的Tom&Jerry》；

       我们再来对比一下程序的执行效率。

       使用互斥锁的方式，执行返回数据如下：

       data len=, time=4

       使用channel的方式，执行返回数据如下：

       data len=, time=

       可以看出，这种很简单的针对map并发读写的场景，通过互斥锁的方式比channel的方式要快很多，毕竟channel的方式增加了channel的读写操作，而且channel的串行化处理，效率上也会低一些。

       所以，根据具体的情况，我们可以考虑优先用什么方式来实现。

       优先使用互斥锁的场景：

       1 复杂且频繁的数据读写操作，如：缓存数据；

       2 应用中全局的共享数据，如：全局变量；

       优先使用channel的场景：

       1 协程之间局部传递共享数据，如：订阅发布模式；

       2 统一的数据处理服务，如：库存更新+订单处理；

       至此，我们已经通过3个Go实例讲解，知道在并发读写的情况下，如何搞定线程安全性问题，简单的数据结构就是int类型的安全读写，复杂的数据结构分别详细讲解了slice和map。在这次map的讲解中，还对比了互斥锁和channel的方式，希望大家能够对并发编程有更深入的理解。