皮皮网

1.map在golang的底层实现和源码分析
2.golang map 源码解读（8问）
3.golangmap并发安全？
4.go map and slice 2021-10-08
5.Golang中map的遍历顺序到底是怎样的？
6.浅谈Golang两种线程安全的map

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的初始化分为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，rsa vc源码获得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来删除元素，不会影响遍历的顺序。

golangmap并发安全？

       ä¸ºä»€ä¹ˆç”¨golang作为游戏服务端的开发语言,它的并发性如何

       é’ˆå¯¹ç½‘游的这些特点，golang的语言特性十分适合开发游戏服务器端。首先，go语言提供goroutine机制作为原生的并发机制。每个goroutine所需的内存很少，实际应用中可以启动大量的goroutine对并发连接进行响应。

       golang在近些年被追捧，不管某华，某阿在很多服务器开发上都在使用。

       golang是一编译型的强类型语言，它在开发上的高效率主要来自于后发优势，不用考虑旧有恶心的历史，又有一个较高的工程视角。

       Golang中sync.Map的实现原理

       å‰é¢ï¼Œæˆ‘们讲了map的用法以及原理Golang中map的实现原理，但我们知道，map在并发读写的情况下是不安全。

       sync.Map是9才推荐的并发安全的map，除了互斥量以外，还运用了原子操作，所以在这之前，有必要了解下Go语言——原子操作go\src\sync\map.goentry分为三种情况：从read中读取key，如果key存在就tryStore。

       æ€»ä½“来说golang的map是hashmap，是使用数组+链表的形式实现的，使用拉链法消除hash冲突。

go面试题整理(附带部分自己的解答)

       æž„，且字符串于等于。如果允许其他额外储存结构，这个题很好做。如果不允许的话，可以使golang内置的式实现。

       Go官方在经过了长时间的讨论后，认为Gomap更应适配典型使用场景(不需要从多个goroutine中进行安全访问)，而不是为了小部分情况(并发访问)，导致大部分程序付出加锁代价(性能)，决定了不支持。

       é¢è¯•åˆ†é’Ÿå¿…问问题及完美回答1面试必问问题及漂亮回答：请你自我介绍一下自己好吗回答提示：一般人回答这个问题过于平常，只说姓名、年龄、爱好、工作经验，这些在简历上都有。

       è§£ç­”：打开一盏灯分钟，关掉，打开第二盏，进去看看哪盏亮，摸摸哪盏热，热的是第一个打开的开关开的，亮的是第二个开关开的，另一个就是第三个。

       ä¸€å…±æ•´ç†äº†ä¸ªé¢˜ç›®ã€‚内容涵盖时序，功耗，PD，PV，工艺等方面，难度由简入繁，分为5个等级，难度指数说明如下：1：常识，这个都回答不了的话回家先闭门思过啦。0~1年工作经验。2：简单，面试前稍微准备一下应该都能回答。

golangmap和数据库哪个性能好

       golangmap和mysql性能好，go语言非常容易入门。如果是有别的语言基础，如python、java等，可能只需要几个小时就可以基本掌握这门语言并可以使用它。当然如果要精通它，还需要一定的时间。

       ä½†ï¼Œå½“数据量趋向无限大的时候，数据库的效率会更高。正确使用数据库的index以及正确的设计ER，会大大提高数据库的效率。两者目的不同。

       Go官方在经过了长时间的讨论后，认为Gomap更应适配典型使用场景(不需要从多个goroutine中进行安全访问)，而不是为了小部分情况(并发访问)，导致大部分程序付出加锁代价(性能)，决定了不支持。

       Go中不存在引用传递，所有的参数传递都是值传递，而map是等同于指针类型的，所以在把map变量传递给函数时，函数对map的修改，也会实质改变map的值。

       ç„¶åŽå°±è¦çœ‹å…ƒç´ åœ¨bucket中的存储结构了。以上就是gomap的大体结构和实现方法了。

       æ‰€ä»¥ï¼Œä½†ä»Žæ€§èƒ½ä¸Šè®²HashMap中的链表出现越少，性能越好；当然，当存储的键值对非常多时，从存储的角度链表又能分担一定的压力。首先，HashMap存储的是键值对，所以需要一个键值对类型。

go map and slice --

        golang是值传递，什么情况下都是值传递

        那么，如果结构中不含指针，则直接赋值就是深度拷贝；

        如果结构中含有指针（包括自定义指针，以及slice，map等使用了指针的内置类型），则数据源和拷贝之间对应指针会共同指向同一块内存，这时深度拷贝需要特别处理。因为值传递只是把指针拷贝了

        map源码:

        /golang/go/blob/a7acf9afbdcfabfdf4/src/runtime/map.go

        map最重要的两个结构体：hmap 和 bmap

        其中 hmap 充当了哈希表中数组的角色， bmap充当了链表的角色。

        其中，单个bucket是一个叫bmap的结构体.

        Each bucket contains up to 8 key/elem pairs.

        And the low-order bits of the hash are used to select a bucket. Each bucket contains a few high-order bits of each hash to distinguish the entries within a single bucket.

        hash值的低位用来定位bucket，高位用来定位bucket内部的key

        根据上面bmap的注释和 /golang/go/blob/go1..8/src/cmd/compile/internal/gc/reflect.go ，

        我们可以推出bmap的结构实际是

        注意：在哈希桶中，键值之间并不是相邻排列的，而是键放在一起，值放在一起，来减少因为键值类型不同而产生的不必要的内存对齐

        例如map[int]int8，如果 key/elem/key/elem这样存放，那么int8类型的值就要padding 7个字节共bits

        更多可参考

        /p/

        /articles/

        因此，slice、map作为参数传递给函数形参，在函数内部的改动会影响到原slice、map

Golang中map的遍历顺序到底是怎样的？

       在Golang中，对map的多次遍历所得序列可能不同。这一设计考虑是为了防止开发者误以为每次遍历map都会得到稳定的输出序列，从而依赖于这一特性进行开发，导致潜在的bug。

       当使用range循环遍历map时，迭代顺序未指定，并且不能保证在每次迭代中相同。自Go 1.0版本起，运行时会随机化map的迭代顺序。开发者最初依赖于Go早期版本中稳定的迭代顺序，但这种顺序在不同实现之间有所差异，导致了可移植性问题。如果需要稳定的迭代顺序，必须维护一个单独的数据结构来指定该顺序。

       这种特性是如何实现的？让我们看看源代码（省略无关细节）：

       源码显示，map底层通过fastrand函数生成随机数r，然后通过r进行与操作计算出startBucket和offset，再调用mapiternext进行遍历。因此，每次遍历map的起点都是随机的，从而导致不同的输出序列。

       在许多博客和文章中，都说map的遍历是随机选择一个起点然后开始遍历的，只有少数提到了遍历顺序的，也都是按照bucket和cell的顺序依次遍历。这时，你可能会产生疑问：如果是按照bucket和cell的顺序遍历，那么起点相同，我们得到的序列一定就相同吗？

       接下来，我将展示一段代码：

       注意，我没有直接使用fmt打印key值，因为fmt可能会对map进行排序。你可以在 这里查看排序规则。

       下面是我某一次的运行结果：

       为什么会这样？明明都是从2开始遍历，却得到了不同的遍历序列？

       我重新阅读了mapiternext的源码，终于找到了原因。以下代码已省略无关细节：

       这段代码的逻辑是对于每个新访问的bucket，i在0到bucketCnt（值为8）之间迭代，然后通过offi := (i + it.offset) & (bucketCnt - 1)计算出offi，从而确定我们要访问的cell的位置。到这里，我们已经找到了答案：bucket的顺序确实是一个一个去遍历的，但是ssd固件 源码每次访问一个新的bucket时，我们并不是从0号cell开始访问，而是从offset对应的cell开始访问的！

       以我上面程序的后两行输出为例，第二行的情况可能是这样的（为了方便理解，我直接把key值放在cell中了）：

       这样去遍历，得到的序列自然是：2 7 0 1 3 4 5 6 8 9

       而第三行的输出，可能是下面这样的情形：

       这里offset为0，而0号cell是空的，所以输出的第一个key仍然是2，但这不代表起点是2所在的cell！这样，当我们访问Bucket 0时，就是从0号cell开始访问，于是得到的输出序列为：

       2 7 8 9 0 1 3 4 5 6

浅谈Golang两种线程安全的map

       文章标题：浅谈Golang两种线程安全的map

       导语：本文将深入探讨Golang中的本地缓存库选择与对比，帮助您解决困惑。

       Golang map并发读写测试：

       在Golang中，原生的map在并发场景下的读写操作是线程不安全的，无论key是否相同。具体来说，当并发读写map的不同key时，运行结果会出现并发错误，因为map在读取时会检查hashWriting标志。如果存在该标志，即表示正在写入，此时会报错。在写入时，会设置该标志：h.flags |= hashWriting。设置完成后，系统会取消该标记。

       使用-race编译选项可以检测并发问题，这是通过Golang的源码分析、文章解析和官方博客中详细解释的。

       map+读写锁实现：

       在官方sync.map库推出之前，推荐使用map与读写锁（RWLock）的组合。通过定义一个匿名结构体变量，包含map、RWLock，可以实现读写操作。

       具体操作方法如下：从counter中读取数据，往counter中写入数据。然而，sync.map和这种实现方式有何不同？它在性能优化方面做了哪些改进？

       sync.map实现：

       sync.map使用读写分离策略，通过空间换取时间，优化了并发性能。相较于map+RWLock的实现，它在某些特定场景中减少锁竞争的可能性，因为可以无锁访问read map，并优先操作read map。如果仅操作read map即可满足需求（如增删改查和遍历），则无需操作write map，后者在读写时需要加锁。

       sync.map的源码深入分析：

       接下来，我们将着重探讨sync.Map的源码，以理解其运作原理，包括结构体Map、readOnly、entry等。

       sync.Map方法介绍：

       sync.Map提供了四个关键方法：Store、Load、Delete、Range。具体功能如下：

       Load方法：解释Map.dirty如何提升为Map.read的机制。

       Store方法：介绍tryStore函数、unexpungeLocked函数和dirtyLocked函数的实现。

       Delete方法：简单总结。

       Range方法：简单总结。

       sync.Map总结：

       sync.Map更适用于读取频率远高于更新频率的场景（appendOnly模式，尤其是key存一次，多次读取且不删除的情况），因为在key存在的情况下，读写删操作可以无锁直接访问readOnly。不建议用于频繁插入与读取新值的wince gdi 源码场景，因为这会导致dirty频繁操作，需要频繁加锁和更新read。此时，github开源库orcaman/concurrent-map可能更为合适。

       设计点：expunged：

       expunged是entry.p值的三种状态之一。当使用Store方法插入新key时，会加锁访问dirty，并将readOnly中未被标记为删除的所有entry指针复制到dirty。此时，之前被Delete方法标记为软删除的entry（entry.p被置为nil）都会变为expunged状态。

       sync.map其他问题：

       sync.map为何不实现len方法？这可能涉及成本与收益的权衡。

       orcaman/concurrent-map的适用场景与实现：

       orcaman/concurrent-map适用于反复插入与读取新值的场景。其实现思路是对Golang原生map进行分片加锁，降低锁粒度，从而达到最少的锁等待时间（锁冲突）。

       它实现简单，部分源码如下，包括数据结构和函数介绍。

       后续：

       在其他业务场景中，可能需要本地kv缓存组件库，支持键过期时间设置、淘汰策略、存储优化、GC优化等功能。此时，可能需要了解freecache、gocache、fastcache、bigcache、groupcache等组件库。

       参考链接：

       链接1：/questions//golang-fatal-error-concurrent-map-read-and-map-write/

       链接2：/golang/go/issues/

       链接3：/golang/go/blob/master/src/sync/map.go

       链接4：/orcaman/concurrent-map

Golang并发map？

       Golang中sync.Map的实现原理

       前面，我们讲了map的用法以及原理Golang中map的实现原理，但我们知道，map在并发读写的情况下是不安全。需要并发读写时，一般的做法是加锁，但这样性能并不高，Go语言在1.9版本中提供了一种效率较高的并发安全的sync.Map，今天，我们就来讲讲sync.Map的用法以及原理

       sync.Map与map不同，不是以语言原生形态提供，而是在sync包下的特殊结构：

       我们下来看下sync.Map结构体

       结构体之间的关系如下图所示：

       总结一下：

       Load方法比较简单，总结一下：

       总结如下：

       golandmap底层原理

       map是Go语言中基础的数据结构，在日常的使用中经常被用到。但是它底层是如何实现的呢？

       总体来说golang的map是hashmap，是使用数组+链表的形式实现的，使用拉链法消除hash冲突。

       golang的map由两种重要的结构，hmap和bmap(下文中都有解释)，主要就是hmap中包含一个指向bmap数组的指针，key经过hash函数之后得到一个数，这个数低位用于选择bmap(当作bmap数组指针的下表)，高位用于放在bmap的[8]uint8数组中，用于快速试错。然后一个bmap可以指向下一个bmap(拉链)。

       Golang中map的底层实现是一个散列表，因此实现map的过程实际上就是实现散表的过程。在这个散列表中，主要出现的结构体有两个，一个叫hmap(aheaderforagomap)，一个叫bmap(abucketforaGomap，通常叫其bucket)。这两种结构的样子分别如下所示：

       hmap:

       图中有很多字段，但是便于理解map的架构，你只需要关心的只有一个，就是标红的字段：buckets数组。Golang的map中用于存储的结构是bucket数组。而bucket(即bmap)的结构是怎样的呢？

       bucket：

       相比于hmap，bucket的结构显得简单一些，标红的字段依然是“核心”，我们使用的map中的key和value就存储在这里。“高位哈希值”数组记录的set putall源码是当前bucket中key相关的“索引”，稍后会详细叙述。还有一个字段是一个指向扩容后的bucket的指针，使得bucket会形成一个链表结构。例如下图：

       由此看出hmap和bucket的关系是这样的：

       而bucket又是一个链表，所以，整体的结构应该是这样的：

       哈希表的特点是会有一个哈希函数，对你传来的key进行哈希运算，得到唯一的值，一般情况下都是一个数值。Golang的map中也有这么一个哈希函数，也会算出唯一的值，对于这个值的使用，Golang也是很有意思。

       Golang把求得的值按照用途一分为二：高位和低位。

       如图所示，蓝色为高位，红色为低位。然后低位用于寻找当前key属于hmap中的哪个bucket，而高位用于寻找bucket中的哪个key。上文中提到：bucket中有个属性字段是“高位哈希值”数组，这里存的就是蓝色的高位值，用来声明当前bucket中有哪些“key”，便于搜索查找。需要特别指出的一点是：我们map中的key/value值都是存到同一个数组中的。数组中的顺序是这样的:

       并不是key0/value0/key1/value1的形式，这样做的好处是：在key和value的长度不同的时候，可以消除padding(内存对齐)带来的空间浪费。

       现在，我们可以得到Go语言map的整个的结构图了：(hash结果的低位用于选择把KV放在bmap数组中的哪一个bmap中，高位用于key的快速预览，用于快速试错)

       map的扩容

       当以上的哈希表增长的时候，Go语言会将bucket数组的数量扩充一倍，产生一个新的bucket数组，并将旧数组的数据迁移至新数组。

       加载因子

       判断扩充的条件，就是哈希表中的加载因子(即loadFactor)。

       加载因子是一个阈值，一般表示为：散列包含的元素数除以位置总数。是一种“产生冲突机会”和“空间使用”的平衡与折中：加载因子越小，说明空间空置率高，空间使用率小，但是加载因子越大，说明空间利用率上去了，但是“产生冲突机会”高了。

       每种哈希表的都会有一个加载因子，数值超过加载因子就会为哈希表扩容。

       Golang的map的加载因子的公式是：map长度/2^B(这是代表bmap数组的长度，B是取的低位的位数)阈值是6.5。其中B可以理解为已扩容的次数。

       当Go的map长度增长到大于加载因子所需的map长度时，Go语言就会将产生一个新的bucket数组，然后把旧的bucket数组移到一个属性字段oldbucket中。注意：并不是立刻把旧的数组中的元素转义到新的bucket当中，而是，只有当访问到具体的某个bucket的时候，会把bucket中的数据转移到新的bucket中。

       如下图所示：当扩容的时候，Go的map结构体中，会保存旧的数据，和新生成的数组

       上面部分代表旧的有数据的bucket，下面部分代表新生成的新的bucket。蓝色代表存有数据的bucket，橘**代表空的bucket。

       扩容时map并不会立即把新数据做迁移，而是当访问原来旧bucket的数据的时候，才把旧数据做迁移，如下图：

       注意：这里并不会直接删除旧的bucket，而是把原来的引用去掉，利用GC清除内存。

       map中数据的删除

       如果理解了map的整体结构，那么查找、更新、删除的基本步骤应该都很清楚了。这里不再赘述。

       值得注意的是，找到了map中的数据之后，针对key和value分别做如下操作：

       1

       2

       3

       4

       1、如果``key``是一个指针类型的，则直接将其置为空，等待GC清除；

       2、如果是值类型的，则清除相关内存。

       3、同理，对``value``做相同的操作。

       4、最后把key对应的高位值对应的数组index置为空。

Golang并发读写map安全问题详解

       下面先写一段测试程序，然后看下运行结果：

       运行结果：

       发生了错误，提示：fatalerror:concurrentmapreadandmapwrite，map发生了同时读和写了；但是这个错误并不是每次运行都会出现，就是有的时候会出现，有的时候并不会出现，根据笔者多次运行结果(其他例子，读者可以自己尝试下)来看还会有另外一种报错就是：fatalerror:concurrentmapwrites，就是map发生了同时写，但是只是读是不会有问题的。关于不同的运行结果小伙伴们可以自己写几个例子去测试下。下面就这两个错误的发生，笔者给出如下解释：

       （1）fatalerror:concurrentmapreadandmapwrite

       就是当一个goroutine在写数据，而同时另外一个goroutine要读数据就会报错，不过这个报错也很好理解：还没写完就读，读的数据会有问题，或者反过来还没读完就开始写了，同样会导致读取的数据有问题；

       （2）fatalerror:concurrentmapwrites

       两个goroutine同时写一个内存地址，这种操作也是不允许的，会导致一些比较奇怪的问题；

       总体来看其实就是写map的操作和其他的读或者写同时发生了，导致的报错，做过几年开发的人可能会想到使用锁来解决，比如写map某个key的时候，通过锁来保证其他goroutine不能再对其写或者读了。

       实现思路：

       （1）当写map的某个key时，通过锁来保证其他goroutine不能再对其写或者读了。

       （2）当读map的某个key时，通过锁来保证其他的goroutine不能再对其写，但是可以读。

       于是我们马上想到golang的读写锁貌似符合需求，下面来实现下：

       再来看下运行结果：

       发现没有报错了，并且多次运行的结果都不会报错，说明这个方法是有用的，不过在go1.9版本后就有sync.Map了，不过这个适用场景是读多写少的场景，如果写很多的话效率比较差，具体的原因在这里笔者就不介绍了，后面会写篇文章详细介绍下。

       今天的文章就到这里了，如果有不对的地方欢迎小伙伴给我留言，看到会即时回复的。

彻底理解GolangMap

       本文目录如下，阅读本文后，将一网打尽下面GolangMap相关面试题

       Go中的map是一个指针，占用8个字节，指向hmap结构体;源码src/runtime/map.go中可以看到map的底层结构

       每个map的底层结构是hmap，hmap包含若干个结构为bmap的bucket数组。每个bucket底层都采用链表结构。接下来，我们来详细看下map的结构

       bmap就是我们常说的“桶”，一个桶里面会最多装8个key，这些key之所以会落入同一个桶，是因为它们经过哈希计算后，哈希结果是“一类”的，关于key的定位我们在map的查询和插入中详细说明。在桶内，又会根据key计算出来的hash值的高8位来决定key到底落入桶内的哪个位置（一个桶内最多有8个位置)。

       bucket内存数据结构可视化如下：

       注意到key和value是各自放在一起的，并不是key/value/key/value/...这样的形式。源码里说明这样的好处是在某些情况下可以省略掉padding字段，节省内存空间。

       当map的key和value都不是指针，并且size都小于字节的情况下，会把bmap标记为不含指针，这样可以避免gc时扫描整个hmap。但是，我们看bmap其实有一个overflow的字段，是指针类型的，破坏了bmap不含指针的设想，这时会把overflow移动到extra字段来。

       map是个指针，底层指向hmap，所以是个引用类型

       golang有三个常用的高级类型slice、map、channel,它们都是引用类型，当引用类型作为函数参数时，可能会修改原内容数据。

       golang中没有引用传递，只有值和指针传递。所以map作为函数实参传递时本质上也是值传递，只不过因为map底层数据结构是通过指针指向实际的元素存储空间，在被调函数中修改map，对调用者同样可见，所以map作为函数实参传递时表现出了引用传递的效果。

       因此，传递map时，如果想修改map的内容而不是map本身，函数形参无需使用指针

       map底层数据结构是通过指针指向实际的元素存储空间，这种情况下，对其中一个map的更改，会影响到其他map

       map在没有被修改的情况下，使用range多次遍历map时输出的key和value的顺序可能不同。这是Go语言的设计者们有意为之，在每次range时的顺序被随机化，旨在提示开发者们，Go底层实现并不保证map遍历顺序稳定，请大家不要依赖range遍历结果顺序。

       map本身是无序的，且遍历时顺序还会被随机化，如果想顺序遍历map，需要对mapkey先排序，再按照key的顺序遍历map。

       map默认是并发不安全的，原因如下：

       Go官方在经过了长时间的讨论后，认为Gomap更应适配典型使用场景（不需要从多个goroutine中进行安全访问），而不是为了小部分情况（并发访问），导致大部分程序付出加锁代价（性能），决定了不支持。

       场景:2个协程同时读和写，以下程序会出现致命错误：fatalerror:concurrentmapwrites

       如果想实现map线程安全，有两种方式：

       方式一：使用读写锁map+sync.RWMutex

       方式二：使用golang提供的sync.Map

       sync.map是用读写分离实现的，其思想是空间换时间。和map+RWLock的实现方式相比，它做了一些优化：可以无锁访问readmap，而且会优先操作readmap，倘若只操作readmap就可以满足要求(增删改查遍历)，那就不用去操作writemap(它的读写都要加锁)，所以在某些特定场景中它发生锁竞争的频率会远远小于map+RWLock的实现方式。

       golang中map是一个kv对集合。底层使用hashtable，用链表来解决冲突，出现冲突时，不是每一个key都申请一个结构通过链表串起来，而是以bmap为最小粒度挂载，一个bmap可以放8个kv。在哈希函数的选择上，会在程序启动时，检测cpu是否支持aes，如果支持，则使用aeshash，否则使用memhash。

       map有3钟初始化方式，一般通过make方式创建

       map的创建通过生成汇编码可以知道，make创建map时调用的底层函数是runtime.makemap。如果你的map初始容量小于等于8会发现走的是runtime.fastrand是因为容量小于8时不需要生成多个桶，一个桶的容量就可以满足

       makemap函数会通过fastrand创建一个随机的哈希种子，然后根据传入的hint计算出需要的最小需要的桶的数量，最后再使用makeBucketArray创建用于保存桶的数组，这个方法其实就是根据传入的B计算出的需要创建的桶数量在内存中分配一片连续的空间用于存储数据，在创建桶的过程中还会额外创建一些用于保存溢出数据的桶，数量是2^(B-4)个。初始化完成返回hmap指针。

       找到一个B，使得map的装载因子在正常范围内

       Go语言中读取map有两种语法：带comma和不带comma。当要查询的key不在map里，带comma的用法会返回一个bool型变量提示key是否在map中；而不带comma的语句则会返回一个value类型的零值。如果value是int型就会返回0，如果value是string类型，就会返回空字符串。

       map的查找通过生成汇编码可以知道，根据key的不同类型，编译器会将查找函数用更具体的函数替换，以优化效率：

       函数首先会检查map的标志位flags。如果flags的写标志位此时被置1了，说明有其他协程在执行“写”操作，进而导致程序panic。这也说明了map对协程是不安全的。

       key经过哈希函数计算后，得到的哈希值如下（主流位机下共个bit位）：

       m:桶的个数

       从buckets通过hashm得到对应的bucket，如果bucket正在扩容，并且没有扩容完成，则从oldbuckets得到对应的bucket

       计算hash所在桶编号：

       用上一步哈希值最后的5个bit位，也就是，值为，也就是号桶（范围是0~号桶）

       计算hash所在的槽位:

       用上一步哈希值哈希值的高8个bit位，也就是，转化为十进制，也就是，在号bucket中寻找**tophash值（HOBhash）为*的槽位**，即为key所在位置，找到了2号槽位，这样整个查找过程就结束了。

       如果在bucket中没找到，并且overflow不为空，还要继续去overflowbucket中寻找，直到找到或是所有的key槽位都找遍了，包括所有的overflowbucket。

       通过上面找到了对应的槽位，这里我们再详细分析下key/value值是如何获取的：

       bucket里key的起始地址就是unsafe.Pointer(b)+dataOffset。第i个key的地址就要在此基础上跨过i个key的大小；而我们又知道，value的地址是在所有key之后，因此第i个value的地址还需要加上所有key的偏移。

       通过汇编语言可以看到，向map中插入或者修改key，最终调用的是mapassign函数。

       实际上插入或修改key的语法是一样的，只不过前者操作的key在map中不存在，而后者操作的key存在map中。

       mapassign有一个系列的函数，根据key类型的不同，编译器会将其优化为相应的“快速函数”。

       我们只用研究最一般的赋值函数mapassign。

       map的赋值会附带着map的扩容和迁移，map的扩容只是将底层数组扩大了一倍，并没有进行数据的转移，数据的转移是在扩容后逐步进行的，在迁移的过程中每进行一次赋值（access或者delete）会至少做一次迁移工作。

       1.判断map是否为nil

       每一次进行赋值/删除操作时，只要oldbuckets!=nil则认为正在扩容，会做一次迁移工作，下面会详细说下迁移过程

       根据上面查找过程，查找key所在位置，如果找到则更新，没找到则找空位插入即可

       经过前面迭代寻找动作，若没有找到可插入的位置，意味着需要扩容进行插入，下面会详细说下扩容过程

       通过汇编语言可以看到，向map中删除key，最终调用的是mapdelete函数

       删除的逻辑相对比较简单，大多函数在赋值操作中已经用到过，核心还是找到key的具体位置。寻找过程都是类似的，在bucket中挨个cell寻找。找到对应位置后，对key或者value进行“清零”操作，将count值减1，将对应位置的tophash值置成Empty

       再来说触发map扩容的时机：在向map插入新key的时候，会进行条件检测，符合下面这2个条件，就会触发扩容：

       1、装载因子超过阈值

       源码里定义的阈值是6.5(loadFactorNum/loadFactorDen)，是经过测试后取出的一个比较合理的因子

       我们知道，每个bucket有8个空位，在没有溢出，且所有的桶都装满了的情况下，装载因子算出来的结果是8。因此当装载因子超过6.5时，表明很多bucket都快要装满了，查找效率和插入效率都变低了。在这个时候进行扩容是有必要的。

       对于条件1，元素太多，而bucket数量太少，很简单：将B加1，bucket最大数量(2^B)直接变成原来bucket数量的2倍。于是，就有新老bucket了。注意，这时候元素都在老bucket里，还没迁移到新的bucket来。新bucket只是最大数量变为原来最大数量的2倍(2^B*2)。

       2、overflow的bucket数量过多

       在装载因子比较小的情况下，这时候map的查找和插入效率也很低，而第1点识别不出来这种情况。表面现象就是计算装载因子的分子比较小，即map里元素总数少，但是bucket数量多（真实分配的bucket数量多，包括大量的overflowbucket）

       不难想像造成这种情况的原因：不停地插入、删除元素。先插入很多元素，导致创建了很多bucket，但是装载因子达不到第1点的临界值，未触发扩容来缓解这种情况。之后，删除元素降低元素总数量，再插入很多元素，导致创建很多的overflowbucket，但就是不会触发第1点的规定，你能拿我怎么办？overflowbucket数量太多，导致key会很分散，查找插入效率低得吓人，因此出台第2点规定。这就像是一座空城，房子很多，但是住户很少，都分散了，找起人来很困难

       对于条件2，其实元素没那么多，但是overflowbucket数特别多，说明很多bucket都没装满。解决办法就是开辟一个新bucket空间，将老bucket中的元素移动到新bucket，使得同一个bucket中的key排列地更紧密。这样，原来，在overflowbucket中的key可以移动到bucket中来。结果是节省空间，提高bucket利用率，map的查找和插入效率自然就会提升。

       由于map扩容需要将原有的key/value重新搬迁到新的内存地址，如果有大量的key/value需要搬迁，会非常影响性能。因此Gomap的扩容采取了一种称为“渐进式”的方式，原有的key并不会一次性搬迁完毕，每次最多只会搬迁2个bucket。

       上面说的hashGrow()函数实际上并没有真正地“搬迁”，它只是分配好了新的buckets，并将老的buckets挂到了oldbuckets字段上。真正搬迁buckets的动作在growWork()函数中，而调用growWork()函数的动作是在mapassign和mapdelete函数中。也就是插入或修改、删除key的时候，都会尝试进行搬迁buckets的工作。先检查oldbuckets是否搬迁完毕，具体来说就是检查oldbuckets是否为nil。

       如果未迁移完毕，赋值/删除的时候，扩容完毕后（预分配内存），不会马上就进行迁移。而是采取增量扩容的方式，当有访问到具体bukcet时，才会逐渐的进行迁移（将oldbucket迁移到bucket）

       nevacuate标识的是当前的进度，如果都搬迁完，应该和2^B的长度是一样的

       在evacuate方法实现是把这个位置对应的bucket，以及其冲突链上的数据都转移到新的buckets上。

       转移的判断直接通过tophash就可以，判断tophash中第一个hash值即可

       遍历的过程，就是按顺序遍历bucket，同时按顺序遍历bucket中的key。

       map遍历是无序的，如果想实现有序遍历，可以先对key进行排序

       为什么遍历map是无序的？

       如果发生过迁移，key的位置发生了重大的变化，有些key飞上高枝，有些key则原地不动。这样，遍历map的结果就不可能按原来的顺序了。

       如果就一个写死的map，不会向map进行插入删除的操作，按理说每次遍历这样的map都会返回一个固定顺序的key/value序列吧。但是Go杜绝了这种做法，因为这样会给新手程序员带来误解，以为这是一定会发生的事情，在某些情况下，可能会酿成大错。

       Go做得更绝，当我们在遍历map时，并不是固定地从0号bucket开始遍历，每次都是从一个**随机值序号的bucket开始遍历，并且是从这个bucket的一个随机序号的cell**开始遍历。这样，即使你是一个写死的map，仅仅只是遍历它，也不太可能会返回一个固定序列的key/value对了。