1.JDK成长记7：3张搞懂HashMap底层原理！码阅
2.你认为适合阅读c/c++代码的码阅工具有哪些?
3.Golang中map的遍历顺序到底是怎样的？
4.结合源码探究HashMap初始化容量问题
5.GIS软件SharpMap源码详解及应用基本信息
6....mac下有没有好用的代码阅读器,像windows下的sourceins

JDK成长记7：3张搞懂HashMap底层原理！

       一句话讲，码阅 HashMap底层数据结构，码阅JDK1.7数组+单向链表、码阅JDK1.8数组+单向链表+红黑树。码阅移码换源码

       在看过了ArrayList、码阅LinkedList的码阅底层源码后，相信你对阅读JDK源码已经轻车熟路了。码阅除了List很多时候你使用最多的码阅还有Map和Set。接下来我将用三张图和你一起来探索下HashMap的码阅底层核心原理到底有哪些？

       首先你应该知道HashMap的核心方法之一就是put。我们带着如下几个问题来看下图：

       如上图所示，码阅put方法调用了putVal方法，码阅之后主要脉络是码阅：

       如何计算hash值？

       计算hash值的算法就在第一步，对key值进行hashCode()后，码阅对hashCode的值进行无符号右移位和hashCode值进行了异或操作。为什么这么做呢？其实涉及了很多数学知识，简单的说就是尽可能让高和低位参与运算，可以减少hash值的冲突。

       默认容量和扩容阈值是多少？

       如上图所示，很明显第二步回调用resize方法，获取到默认容量为，这个在源码里是1<<4得到的，1左移4位得到的。之后由于默认扩容因子是0.，所以两者相乘就是扩容大小阈值*0.=。之后就分配了一个大小为的Node[]数组，作为Key-Value对存放的数据结构。

       最后一问题是，如何进行hash寻址的？

       hash寻址其实就在数组中找一个位置的意思。用的算法其实也很简单，就是用数组大小和hash值进行n-1&hash运算，这个操作和对hash取模很类似，只不过这样效率更高而已。hash寻址后，就得到了一个位置，可以把key-value的Node元素放入到之前创建好的Node[]数组中了。

       当你了解了上面的三个原理后，你还需要掌握如下几个问题:

       还是老规矩，看如下图：

       当hash值计算一致，比如当hash值都是时，Key-Value对的Node节点还有一个next指针，会以单链表的形式，将冲突的节点挂在数组同样位置。这就是数据结构中所提到解决hash 的冲突方法之一：单链法。当然还有探测法+rehash法有兴趣的人可以回顾《数据结构和算法》相关书籍。

       但是当hash冲突严重的时候，单链法会造成原理链接过长，导致HashMap性能下降，因为链表需要逐个遍历性能很差。所以JDK1.8对hash冲突的算法进行了优化。当链表节点数达到8个的时候，会自动转换为红黑树，自平衡的一种二叉树，有很多特点，比如区分红和黑节点等，具体大家可以看小灰算法图解。红黑树的遍历效率是O(logn)肯定比单链表的O(n)要好很多。

       总结一句话就是，hash冲突使用单链表法+红黑树来解决的。

       上面的图，核心脉络是四步，源码具体的就不粘出来了。当put一个之后，map的size达到扩容阈值，就会触发rehash。你可以看到如下具体思路：

       情况1:如果数组位置只有一个值：使用新的容量进行rehash，即e.hash & (newCap - 1)

       情况2:如果数组位置有链表，根据 e.hash & oldCap == 0进行判断，结果为0的使用原位置，否则使用index + oldCap位置,放入元素形成新链表，这里不会和情况1新的容量进行rehash与运算了，index + oldCap这样更省性能。

       情况3：如果数组位置有红黑树，根据split方法，同样根据 e.hash & oldCap == 0进行树节点个数统计，如果个数小于6，将树的结果恢复为普通Node，否则使用index + oldCap，调整红黑树位置，这里不会和新的容量进行rehash与运算了，index + oldCap这样更省性能。

       你有兴趣的话，可以分别画一下这三种情况的图。这里给大家一个图，假设都出发了以上三种情况结果如下所示：

       上面源码核心脉络，3个if主要是校验了一堆，没做什么事情，之后赋值了扩容因子，不传递使用默认值0.，扩容阈值threshold通过tableSizeFor(initialCapacity);进行计算。注意这里只是计算了扩容阈值，没有初始化数组。手机游戏墙源码代码如下：

       竟然不是大小*扩容因子？

       n |= n >>> 1这句话，是在干什么？n |= n >>> 1等价于n = n | n >>>1; 而|表示位运算中的或，n>>>1表示无符号右移1位。遇到这种情况，之前你应该学到了，如果碰见复杂逻辑和算法方法就是画图或者举例子。这里你就可以举个例子：假设现在指定的容量大小是,n=cap-1=，那么计算过程应该如下：

       n是int类型，java中一般是4个字节，位。所以的二进制： 。

       最后n+1=，方法返回，赋值给threshold=。再次注意这里只是计算了扩容阈值，没有初始化数组。

       为什么这么做呢？一句话，为了提高hash寻址和扩容计算的的效率。

       因为无论扩容计算还是寻址计算，都是二进制的位运算，效率很快。另外之前你还记得取余(%)操作中如果除数是2的幂次方则等同于与其除数减一的与(&)操作。即 hash%size = hash & (size-1)。这个前提条件是除数是2的幂次方。

       你可以再回顾下resize代码，看看指定了map容量，第一次put会发生什么。会将扩容阈值threshold，这样在第一次put的时候就会调用newCap = oldThr;使得创建一个容量为threshold的数组，之后从而会计算新的扩容阈值newThr为newCap*0.=*0.=。也就是说map到了个元素就会进行扩容。

       除了今天知识，技能的成长，给大家带来一个金句甜点，结束我今天的分享：坚持的三个秘诀之一目标化。

       坚持的秘诀除了上一节提到的视觉化，第二个秘诀就是目标化。顾名思义，就是需要给自己定立一个目标。这里要提到的是你的目标不要定的太高了。就比如你想要增加肌肉，给自己定了一个目标，每天5组，每次个俯卧撑，你看到自己胖的身形或者海报，很有刺激，结果开始前两天非常厉害，干劲十足，特别奥利给。但是第三天，你想到要个俯卧撑，你就不想起床，就算起来，可能也会把自己撅死过去......其实你的目标不要一下子定的太大，要从微习惯开始，比如我媳妇从来没有做过俯卧撑，就让她每天从1个开始,不能多，我就怕她收不住，做多了。一开始其实从习惯开始，先变成习惯，再开始慢慢加量。量太大养不成习惯，量小才能养成习惯。很容易做到才能养成，你想想是不是这个道理？

       所以，坚持的第二个秘诀就是定一个目标，可以通过小量目标，养成微习惯。比如每天你可以读五分钟书或者5分钟成长记，不要多，我想超过你也会睡着了的.....

       最后，大家可以在阅读完源码后，在茶余饭后的时候问问同事或同学，你也可以分享下，讲给他听听。

你认为适合阅读c/c++代码的工具有哪些?

       探索适合阅读C/C++代码的工具，CODEMAP源代码阅读器脱颖而出。CODEMAP通过创新的代码编辑器平铺布局方式，实现代码片段间的自动连线，不仅帮助用户快速掌握整体结构，还能通过手动添加高亮、标注等手段，提升代码阅读的直观性和易懂性。对于复杂项目框架分析，CODEMAP展现出卓越的效果，显著提高代码阅读效率。支持包括C、C++在内的多种编程语言，使跨语言协作变得更加便捷。

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的顺序确实是一个一个去遍历的，但是每次访问一个新的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

结合源码探究HashMap初始化容量问题

       探究HashMap初始化容量问题

       在深入研究HashMap源码时，有一个问题引人深思：为何在知道需要存储n个键值对时，我们通常会选择初始化容量为capacity = n / 0. + 1？

       本文旨在解答这一疑惑，适合具备一定HashMap基础知识的读者。请在阅读前，思考以下问题：

       让我们通过解答这些问题，逐步展开对HashMap初始化容量的深入探讨。

       源码探究

       让我们从实际代码出发，通过debug逐步解析HashMap的初始化逻辑。

       举例：初始化一个容量为9的HashMap。

       执行代码后，我们发现初始化容量为，且阈值threshold设置为。

       解析

       通过debug，我们首先关注到构造方法中的初始化逻辑。注意到，初始化阈值时，实际调用的是`tabliSizeFor(int n)`方法，它返回第一个大于等于n的2的幂。例如，`tabliSizeFor(9)`返回，`tabliSizeFor()`返回，`tabliSizeFor(8)`返回8。

       继续解析

       在构造方法结束后，我们通过debug继续追踪至`put`方法，直至`putVal`方法。

       在`putVal`方法中，我们发现当第一次调用`put`时，table为null，从而触发初始化逻辑。在初始化过程中，关键在于`resize()`方法中对新容量`newCap`的初始化，即等于构造方法中设置的阈值`threshold`()。

       阈值更新

       在初始化后，我们进一步关注`updateNewThr`的代码逻辑，发现新的阈值被更新为新容量乘以负载因子，即 * 0.。购物分享源码APP

       案例分析

       举例：初始化一个容量为8的HashMap。

       解答：答案是8，因为`tableSizeFor`方法返回大于等于参数的2的幂，而非严格大于。

       扩容问题

       举例：当初始化容量为时，放入9个不同的entry是否会引发扩容。

       解答：不会，因为扩容条件与阈值有关，当map中存储的键值对数量大于阈值时才触发扩容。根据第一问，初始化容量是，阈值为 * 0. = 9，我们只放了9个，因此不会引起扩容。

       容量选择

       举例：已知需要存储个键值对，如何选择合适的初始化容量。

       解答：初始化容量的目的是减少扩容次数以提高效率并节省空间。选择容量时，应考虑既能防止频繁扩容又能充分利用空间。具体选择取决于实际需求和预期键值对的数量。

       总结

       通过本文的探讨，我们深入了解了HashMap初始化容量背后的逻辑和原因。希望这些解析能够帮助您更深入地理解HashMap的内部工作原理。如果您对此有任何疑问或不同的见解，欢迎在评论区讨论。

       最后，如有帮助，欢迎点赞分享。

GIS软件SharpMap源码详解及应用基本信息

       本书《GIS软件SharpMap源码详解及应用》由陈真、何津、余瑞编著，内容详尽剖析了基于C#语言开发的GIS开源项目——SharpMap。全书分为三大部分，共计十一章，旨在帮助GIS专业学生及初学者掌握GIS底层开发技术。第一部分深入讲解SharpMap源码，涉及地图、地图控件、图层、绘制、样式、数据、几何对象等核心内容。第二部分介绍基于SharpMap的应用开发，具体包括两个SharpMap下载包中附带的Windows应用程序的开发。第三部分探讨SharpMap系统扩展，详细覆盖数据源对象扩展及图层对象扩展。

       本书适合地理信息系统相关专业本科生学习“GIS开发与设计”等课程，也适合对GIS感兴趣的初学者及GIS工程技术人员作为参考阅读。其特别之处在于针对当前.NET平台GIS开源项目稀缺的现状，通过详尽讲解SharpMap的核心模块，解决SharpMap开发文档匮乏的问题。这本书不仅提供了一套简单易用的小型GIS平台，支持多种GIS数据格式，还支持空间查询，能渲染出精美地图。

       本书内容涉及SharpMap的特性、支持的GIS数据格式、名称空间概述、用到的第三方库、源代码下载等基础知识，以及地图、地图控件、图层、绘制、样式、数据、几何对象等核心模块的深入解析。此外，本书还详细介绍了SharpMap在Windows应用程序开发中的应用，包括两个附带的Windows应用程序的开发实例，以及数据源扩展与图层对象扩展的扩展内容。通过本书的学习，读者可以全面掌握SharpMap的使用与开发技巧，为从事GIS相关工作打下坚实基础。

       综上所述，本书《GIS软件SharpMap源码详解及应用》为GIS开发人员提供了一个深入理解SharpMap内部机制的宝贵资源。无论是学习GIS底层技术，还是实际开发GIS应用，本书都能提供详尽指导，帮助读者快速掌握SharpMap的开发与应用技巧，从而在GIS领域发挥更大作用。

...mac下有没有好用的代码阅读器,像windows下的sourceins

       在寻找Mac下好用的代码阅读器时，推荐尝试CODEMAP源代码阅读器。它具备友好易上手的特点，即便是代码新手，也能在较短时间内掌握使用方法。

       CODEMAP源代码阅读器为用户提供了简洁直观的界面，使得代码阅读变得更加轻松。它支持多种编程语言，包括但不限于Python、Java、分享转发源码C++等，几乎能满足各类开发需求。

       此外，CODEMAP源代码阅读器还具备代码高亮显示、代码折叠、快捷查找等功能，帮助开发者更高效地浏览和理解代码逻辑。这些功能使得代码阅读过程变得更加流畅，有助于提高代码阅读效率。

       为了更好地理解和使用CODEMAP源代码阅读器，可以参考以下相关演示视频。视频中详细介绍了该工具的使用方法和高级功能，帮助用户快速掌握其应用。

       观看演示视频地址：bilibili.com/video/BV1V...

有人用过sourcetrail这个代码阅读工具吗,体验怎么样?

       尝试使用 CODEMAP源代码阅读器进行代码阅读体验如何？答案是：极佳。

       在阅读他人代码时，我们常常需要在不同文件间频繁跳转，同时记忆函数名称、所在行数及文件名。对于复杂的项目，还需要记住不同文件夹路径，这给学习带来巨大负担。常规方法是在本地环境中切换到早期版本，通过设置断点或命令行打印来追踪逻辑流程。然而，在复杂项目中，逻辑结构复杂，调用层次过深，多次文件间跳转和调用会令人感到疲惫。

       CODEMAP源代码阅读器解决了上述问题，它通过代码编辑器平铺布局，自动连接跳转结构，手动添加高亮和标注，使代码结构清晰易懂。以下是演示相关视频链接：

       bilibili.com/video/BV1V...

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就存储在这里。“高位哈希值”数组记录的是当前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对了。

Java 8 中 Map 骚操作之 merge() 的用法

       本文将浅析 Java 8 中 Map 类的骚操作之一：merge() 方法的使用方法及其相关应用场景。在介绍 merge() 方法之前，我们首先通过一个例子来直观理解它的作用。

       假设我们面临一个业务场景，即有一个包含学生姓名、科目和科目分数的学生成绩对象列表。任务要求是计算每个学生的总成绩。面对这样一个需求，常规方法可能涉及到循环和额外的逻辑来累计分数。然而，利用 map.merge() 方法，我们可以简化这一过程。

       接下来，我们对比常规做法与使用 merge() 方法的不同之处。常规做法可能涉及遍历列表，并在哈希映射中累计分数。而通过 merge() 方法，我们可以直接在循环中计算总成绩，同时处理学生不存在总成绩的情况。

       merge() 方法的原理相对直观，它接收三个参数：键、值和一个重映射函数。如果键不存在，方法会像 put(key, value) 一样操作。如果键已存在，重映射函数可以根据当前值和新值生成合并后的值，并更新映射。

       merge() 方法适用场景广泛，特别是在需要在循环中进行分组求和操作时。虽然 Java 8 提供了 groupingBy() 方法来实现类似功能，但在循环中进行其他操作时，merge() 方法可能更为灵活。

       除此之外，Java 8 中还有其他与 map 相关的方法，如 putIfAbsent、compute()、computeIfAbsent() 和 computeIfPresent 等，它们各自服务于特定需求。虽然本文不详细介绍这些方法，但它们的名称暗示了各自的功能，有兴趣的读者可自行查阅源码。

       总结而言，merge() 方法为处理映射中的键值对提供了一种高效且灵活的方式，特别是在计算累计值、合并数据时大显身手。对于 Java 8 中的 HashMap 实现，虽然其底层使用了 TreeNode 和红黑树，可能对源码阅读造成一定的挑战，但理解其原理和逻辑是关键。通过阅读源码和实践，我们可以更好地掌握 map 类的方法及其应用。

       作者：LQ木头