皮皮网

1.HashMap、HashTable、ConcurrentHashMap的原理与区别
2.如何在java中使用ConcurrentHashMap
3.面试篇-ConcurrentHashMap的线程安全实现原理及应用
4.一图了解ConcurrentHashMap底层原理
5.简单说说ConcurrentSkipListMap
6.concurrenthashmap1.8源码如何详细解析?

HashMap、HashTable、ConcurrentHashMap的原理与区别

       

        从类图中可以看出来在存储结构中ConcurrentHashMap比HashMap多出了一个类Segment。ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一个可重入锁（ReentrantLock），在ConcurrentHashMap里扮演锁的角色；HashEntry则用于存储键值对数据。一个ConcurrentHashMap里包含一个Segment数组。Segment的结构和HashMap类似，是一种数组和链表结构。一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构的元素，每个Segment守护着一个HashEntry数组里的元素。当对HashEntry数组的数据进行修改时，必须首先获得与它对应的segment锁。

        ConcurrentHashMap是使用了锁分段技术来保证线程安全的。

        锁分段技术：首先将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。

        ConcurrentHashMap提供了与Hashtable和SynchronizedMap不同的锁机制。Hashtable中采用的锁机制是一次锁住整个hash表，从而在同一时刻只能由一个线程对其进行操作；而ConcurrentHashMap中则是一次锁住一个桶。

        Hashtable容器在竞争激烈的并发环境下表现出效率低下的原因是因为所有访问Hashtable的线程都必须竞争同一把锁，假如容器里有多把锁，每一把锁用于锁容器其中一部分数据，那么当多线程访问容器里不同数据段的数据时，线程间就不会存在锁竞争，从而可以有效提高并发访问效率，这就是ConcurrentHashMap所使用的锁分段技术。首先将数据分成一段一段存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其它段的数据也能被其它线程访问。

如何在java中使用ConcurrentHashMap

       å‚考如下内容:

       ConcurrentHashMap锁的方式是稍微细粒度的。 ConcurrentHashMap将hash表分为个桶（默认值），诸如get,put,remove等常用操作只锁当前需要用到的桶。

       è¯•æƒ³ï¼ŒåŽŸæ¥ 只能一个线程进入，现在却能同时个写线程进入（写线程才需要锁定，而读线程几乎不受限制，之后会提到），并发性的提升是显而易见的。

       æ›´ä»¤äººæƒŠè®¶çš„是ConcurrentHashMap的读取并发，因为在读取的大多数时候都没有用到锁定，所以读取操作几乎是完全的并发操作，而写操作锁定的粒度又非常细，比起之前又更加快速（这一点在桶更多时表现得更明显些）。只有在求size等操作时才需要锁定整个表。

       è€Œåœ¨è¿­ä»£æ—¶ï¼ŒConcurrentHashMap使用了不同于传统集合的快速失败迭代器的另一种迭代方式，我们称为弱一致迭代器。在这种迭代方式中，当iterator被创建后集合再发生改变就不再是抛出 ConcurrentModificationException，取而代之的是在改变时new新的数据从而不影响原有的数 据，iterator完成后再将头指针替换为新的数据，这样iterator线程可以使用原来老的数据，而写线程也可以并发的完成改变，更重要的，这保证了多个线程并发执行的连续性和扩展性，是性能提升的关键。

       ä¸‹é¢åˆ†æžConcurrentHashMap的源码。主要是分析其中的Segment。因为操作基本上都是在Segment上的。先看Segment内部数据的定义。

面试篇-ConcurrentHashMap的线程安全实现原理及应用

       面试中常常涉及的ConcurrentHashMap，它是Java中一个重要的线程安全数据结构。不同于非线程安全的HashMap，ConcurrentHashMap允许多线程同时操作，无需额外的同步措施。其工作原理基于哈希函数将键映射到桶，源码原装结合链表或红黑树等数据结构处理哈希冲突，关键在于采用了分段锁机制。

       分段锁将散列表划分为多个独立的段，每个段都有自己的锁。这意味着当一个线程修改某个桶时，只会锁定对应的段，而不是殷保华源码整个表。这样，多个线程可以并发访问和修改不同段，极大地提高了并发性能，保证了线程间的协作安全。

       与HashMap相比，ConcurrentHashMap的扩容机制有所不同。当存储元素数量达到阈值，它会自动扩展容量，同时确保在扩容过程中，新添加的键值对会被插入到新的桶，而非旧的。这一过程不会阻塞其他线程，wap商场源码确保了并发访问的连续性。

       总的来说，面试时了解ConcurrentHashMap的线程安全实现原理及其与HashMap的区别，有助于深入理解其在多线程环境中的高效应用。

一图了解ConcurrentHashMap底层原理

       1、ConcurrentHashMap底层数据结构是一个数组table

        2、table数组上挂着单向链表或红黑树

        3、new ConcurrentHashMap();如果没有指定长度的话，默认是，并且数组长度必须是2的n次幂，若自定义初始化的长度不是2的n次幂，那么在初始化数组时，会吧数组长度设置为大于自定义长度的最近的2的n次幂。（如：自定义长度为7，那么实际初始化数组后的长度为8）

        4、底层是使用synchronized作为同步锁，并且锁的粒度是数组的具体索引位（有些人称之为分段锁）。

        5、Node节点，hash>0，当hash冲突时，会形成一个单向链表挂在数组上。

        6、ForwardindNode，继承至Node，其hash=-1，表示当前索引位的数据已经被迁移到新数组上了

        7、ReservationNode，继承至Node，其hash=-3，表示当前索引位被占用了（compute方法）

        8、TreenBin，继承至Node，其hash=-2，代表当前索引下挂着一颗红黑树

        9、lockState为ConcurrentHashMap底层自己实现的基于cas的读写锁，锁粒度是具体的某颗树。当向红黑树进行增，删操作时，首先会先上sync同步锁，然后自平衡的时候会上lockState写锁，当读红黑树的时候，会上lockState读锁，然后判断此时是否有线程正持有写锁，或是否有线程正在等待获取写锁，若有，则读线程会直接去读双向链表，而不是去读红黑树。

        、TreeNode，hash>0，为红黑树具体节点。TreeBin的root代表红黑树的根节点，first代表双向链表的第一个节点

        、双向链表：构建红黑树时还维护了一个双向链表，其目的为：(1)当并发写读同一颗红黑树的时候，读线程判断到有线程正持有写锁，那么会跑去读取双向链表，避免因为并发写读导致读线程等待或阻塞。(2)当扩容的时候，会去遍历双向链表，重新计算节点hash，根据新的hash判断放在新数组的高位还是地位

        1、触发扩容的规则：

        1）添加完元素后，若判断到当前容器元素个数达到了扩容的阈值（数组长度*0.），则会触发扩容

        2）添加完元素后，所在的单向链表长度>=8，则会转为红黑树，不过在转红黑树之前会判断数组长度是否小于，若小于则会触发扩容

        2、table为扩容前的数组，nextTable为扩容中创建的新数组，迁移数据完毕后需要将nextTable赋值给table

        3、扩容后的数组是元素组长度的2倍

        4、ln，hn分别表示高位和低位的链表（高链，低链）。即，扩容时，会用n&h==0来判断元素应该放在新数组的i位置还是i+n位置。n：元素组长度；h：元素hash值；i：元素所在的原数组索引位；。这样就会出现有些元素会被挂在低位，有些元素会被挂在高位，从而达到打散元素的目的。

        5、红黑树扩容时，会遍历双向链表，并且计算n&h==0来判断元素放在低位（lo）还是高位（ho），确定完元素的去处之后，会判断分别判断两个双向链表（lo,ho）的长度是否大于6，若大于6则将还是以一颗红黑树的结构挂在数组上，若<=6的话，则转为单向链表，挂在数组上

简单说说ConcurrentSkipListMap

       åŸºæœ¬ä»‹ç»

       è·³è·ƒè¡¨çš„性质如下：

       æœ€åº•å±‚的数据节点按照关键字key升序排列；

       åŒ…含多级索引，每个级别的索引节点按照其关联的数据节点的关键字key升序排列；

       é«˜çº§åˆ«ç´¢å¼•æ˜¯å…¶ä½Žçº§åˆ«ç´¢å¼•çš„子集；

       å¦‚果关键字key在级别level=i的索引中出现，则级别level<=i的所有索引都包含该key。

       è·³è·ƒè¡¨ConcurrentSkipListMap的数据结构如下图所示，下图一共有三层索引，最底下为数据节点，同一层索引中，索引节点之间使用right指针相连，上层索引节点的down指针指向下层的索引节点。

源码分析核心字段分析

       head 指向 node(BASE_HEADER) 的顶层索引。

/***Thetopmostheadindexoftheskiplist.*/privatetransientvolatileHeadIndex<K,V>head;

       BASE_HEADER 头结点，即最顶层索引的头节点的value值

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()

       Node 静态内部类，即数据节点

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}

       Index 静态内部类，即普通索引节点

/***普通索引节点*/staticclassIndex<K,V>{ finalNode<K,V>node;//索引节点指向的数据节点finalIndex<K,V>down;//当前索引节点的正下方索引节点volatileIndex<K,V>right;//当前索引节点的右索引节点/***Createsindexnodewithgivenvalues.*/Index(Node<K,V>node,Index<K,V>down,Index<K,V>right){ this.node=node;this.down=down;this.right=right;}}

       HeadIndex 静态内部类，即当前级别索引的头节点

/***当前级别索引的头节点*/staticfinalclassHeadIndex<K,V>extendsIndex<K,V>{ finalintlevel;//所处索引级别/***node：当前索引指向的数据节点*down：当前索引节点的正下方索引节点*right：当前索引节点的右索引节点*level：当前索引头节点所处的索引级别*/HeadIndex(Node<K,V>node,Index<K,V>down,Index<K,V>right,intlevel){ super(node,down,right);this.level=level;}}查询

       æ ¹æ®æŒ‡å®šçš„key查询节点，源码如下：

publicVget(Objectkey){ //调用doGet方法returndoGet(key);}/***真正实现查询方法*/privateVdoGet(Objectkey){ if(key==null)thrownewNullPointerException();Comparator<?superK>cmp=comparator;outer:for(;;){ for(Node<K,V>b=findPredecessor(key,cmp),n=b.next;;){ Objectv;intc;if(n==null)breakouter;Node<K,V>f=n.next;if(n!=b.next)//inconsistentreadbreak;if((v=n.value)==null){ //nisdeletedn.helpDelete(b,f);break;}if(b.value==null||v==n)//bisdeletedbreak;if((c=cpr(cmp,key,n.key))==0){ @SuppressWarnings("unchecked")Vvv=(V)v;returnvv;}if(c<0)breakouter;b=n;n=f;}}returnnull;}

       åœ¨ä¸Šè¿°ä»£ç ä¸­ï¼Œouter处的for自旋中，首先查看findPredecessor：查询指定key节点的前驱节点。该方法在下面的好多地方会调用，例如插入元素，删除元素以及删除元素对应的索引时都会调用。

       findPredecessor方法源码如下：

/***作用1：找到key对应节点的前驱节点，不一定的真的前驱节点，也可能是前驱结点的前驱节点*作用2：删除无效的索引，即要删除节点时，将节点的索引也删除掉*/privateNode<K,V>findPredecessor(Objectkey,Comparator<?superK>cmp){ if(key==null)thrownewNullPointerException();//don'tpostponeerrorsfor(;;){ //r为q节点的右指针指向的节点，r为当前比较节点,每次都比较r节点的key跟查找的key的大小关系for(Index<K,V>q=head,r=q.right,d;;){ if(r!=null){ Node<K,V>n=r.node;Kk=n.key;//该节点已经删除，需要删除其对应的索引if(n.value==null){ //该节点已经删除，需要删除其对应的索引if(!q.unlink(r))break;//restartr=q.right;//rereadrcontinue;}//当前查找的key比r节点的key大，所以r、q节点都向右移动if(cpr(cmp,key,k)>0){ q=r;r=r.right;continue;}}//当q的下方索引节点为空，则说明已经到数据节点层了，需要退出进行后续查找处理if((d=q.down)==null)returnq.node;/***此时当前查找的key小于r节点的key，需要往下一级索引查找*d节点赋值为为q节点为正下方节点，即下一级索引的正下方节点*/q=d;r=d.right;}}}

       findPredecessor方法的查找过程图示如下：假设要查找节点6

       ç”±äºŽå½“前r节点的key比查询的key小，所以，r、q节点都向右移动，即执行如下代码：

//当前查找的key比r节点的key大，所以r、q节点都向右移动if(cpr(cmp,key,k)>0){ q=r;r=r.right;continue;}

       æ­¤æ—¶r节点指向的数据节点为，节点的key比6节点的key大，此时需要执行如下代码：

/***此时当前查找的key小于r节点的key，需要往下一级索引查找*d节点赋值为为q节点为正下方节点，即下一级索引的正下方节点*/q=d;r=d.right;

       æ­¤æ—¶r节点指向的数据节点为5，5节点的key比6节点的key小，q、r节点向右移动，如下图所示

       æ­¤æ—¶r节点指向的数据节点为，节点的key比6节点的key大，同理需要往下级索引走，如下图所示：

       æ­¤æ—¶r节点指向的数据节点为，节点的key比6节点的key大，同理需要往下级索引走，但是此时下一级索引为空了，即(d = q.down) == null了，此时执行的代码如下， 返回q索引指向的节点，即返回节点5.

//当q的下方索引节点为空，则说明已经到数据节点层了，需要退出进行后续查找处理if((d=q.down)==null)returnq.node;

       ä»¥ä¸Šå°±æ˜¯æ–¹æ³•findPredecessor的查找流程，咱们接着继续看上面的doGet方法

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()0

       é¦–先初始化b、n、f三个节点，如下图所示

        发现此时n节点指向的节点就是要查询的节点，于是执行如下代码：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()1

       ç›´æŽ¥è¿”回n节点的value值。查询操作完成。

插入

       è·³è·ƒè¡¨çš„插入操作分以下四种情况：

       æƒ…况1：跳跃表内存在key一致元素，做替换

       æƒ…况2：插入新元素，无须给新元素生成索引节点

       æƒ…况3：插入新元素，需要给新元素生成索引节点，且索引高度 < maxLevel

       æƒ…况4：插入新元素，需要给新元素生成索引节点，且索引高度 > maxLevel

       æºç å¦‚下：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()2

       é¦–先还是跟查询操作类似，调用findPredecessor方法先查找到待插入key的前驱节点，举个例子，例如我们想要插入节点7，如下图所示：

       æŽ¥ç€è·ŸæŸ¥è¯¢æ“ä½œä¸€æ ·çš„步骤如下，直接看图：

        此时r节点指向数据节点1，节点1的key小于待插入的节点7的key，于是节点q、r同时向右移动。

       æ­¤æ—¶r节点指向数据节点，节点的key大于待插入节点7的key，于是往下一层索引继续查找，执行的代码如下：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()3

       åŽé¢çš„操作类似

       æ­¤æ—¶r节点的key大于待插入的节点6的key，但是q节点的down指针已为空，此时直接返回q节点指向的节点5。

       æŽ¥ç€å›žåˆ°doPut方法，先来查看outer循环，如下：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()4

       é¦–先初始化三个节点b、n、f，n节点为b节点的下一个节点，而f节点为n节点的下一个节点，如下图所示

       æŽ¥ç€æ¯”较节点n与待插入的key的大小，此时n节点的key小于待插入节点的key，于是b、n、f三个节点均向下移动如下图所示

       æ­¤æ—¶n节点的key大于待插入的key，此时执行如下代码，通过cas方式修改b节点的下一个节点为z节点，接着跳出outer循环。

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()5

       ç„¶åŽæˆ‘们知道doPut剩下的代码无非就是判断是否给新插入的节点z创建索引，如果需要创建对应的索引。

       é¦–先通过int rnd = ThreadLocalRandom.nextSecondarySeed();计算出一个随机数，接着进行如下判断：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()6

       å¦‚æžœrnd & 0x) == 0就给新插入的z节点创建索引，我们知道0x = 即最高位和最后一位为1，其余全部是0，

       æ¡ä»¶ï¼š(rnd & 0x) == 0什么时候成立？

       rnd这个随机数最低位和最高位同时是0的时候，条件成立，概率是1/4

       ä¸¾ä¸ªä¾‹å­ï¼šä¾‹å¦‚rnd = = 3条件就成立。

       å¦‚果条件成立的话，接着计算到底给z节点创建几级索引，代码如下：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()7

       é€šè¿‡while条件((rnd >>>= 1) & 1) != 0满足几次就创建几级索引。例如：

       rnd = 计算出来的level => 3

       rnd = 计算出来的level => 8

       ç„¶åŽæŽ¥ç€æ¯”较计算出来的z节点的索引跟现有的跳跃表的索引级别大小。

       æƒ…况一：z节点计算出来的索引level比跳跃表的level小

       æƒ…况二：z节点计算处理的索引level比跳跃表的level大。此时会选择最终的level为原来的调表的level + 1

       æƒ…况一

       ç»™z节点创建索引的步骤如下图所示，此时z节点的索引还没有加入跳跃表现有的索引队列中

       æŽ¥ç€ç»§ç»­æ‰§è¡Œsplice循环，代码如下：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()8

       åˆå§‹åŒ–q、r节点如下图所示

       æ­¤æ—¶r节点的key比新插入z节点，即7节点小，于是两个节点q、t都向右移动如下图所示

       æ­¤æ—¶r节点的key比新插入z节点，即7节点大，执行如下代码：

/***Specialvalueusedtoidentifybase-levelheader*/privatestaticfinalObjectBASE_HEADER=newObject()9

       æ­¤æ—¶r节点的key比新插入z节点，即7节点小，于是两个节点q、t都向右移动如下图所示

       æ­¤æ—¶r节点的key比新插入z节点，即7节点大,同理，直接看图

       æƒ…况二

       è·Ÿæƒ…况一类似，这里就不一一画图了

删除

       åˆ é™¤æ–¹æ³•å®Œæˆçš„任务如下：

       è®¾ç½®æŒ‡å®šå…ƒç´ value为null

       å°†æŒ‡å®šnode从node链表移除

       å°†æŒ‡å®šnode的index节点 从 对应的 index 链表移除

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}0

       åŒæ ·ï¼Œé¦–先通过findPredecessor方法查找到要删除key的前驱节点，就不一一画图了，直接看找到的前驱节点的图，如下：

       æŽ¥æ¯”较n节点的key与待删除的key的大小，此时n节点的key小于待删除的key，即7节点的key，于是将b、n、f三个节点都向右移动，如下图：

       æ­¤æ—¶n节点的key跟待删除的key一样，于是执行如下代码：

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}1

       æœ€åŽå†è°ƒç”¨findPredecessor清楚无效的索引，即上面删除的节点的索引。

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}2

       é‡ç‚¹é å¦‚下代码块删除索引的：

/***数据节点*/staticfinalclassNode<K,V>{ finalKkey;//数据节点的keyvolatileObjectvalue;//数据节点的valuevolatileNode<K,V>next;//指向下一个数据节点/***Createsanewregularnode.*/Node(Kkey,Objectvalue,Node<K,V>next){ this.key=key;this.value=value;this.next=next;}}3

       æˆ‘们知道在上面已经将待删除的7节点的value置为null了，直接看图：

       æ­¤æ—¶r节点的key小于待删除节点的key，于是r、q节点都向右移动。

       æ­¤æ—¶r,n节点指向的数据节点的value值为null于是执行上面的q.unlink(r)代码，将q的右指针指向r的右指针指向的节点，即就是删除了该level上的7节点的索引节点，如下图所示

       æ­¤æ—¶r节点的key大于待删除节点的key，于是往下一索引走，如下图所示

       æ­¤æ—¶r节点的key小于待删除节点的key，于是r、q节点都向右移动。

       æ­¤æ—¶r,n节点指向的数据节点的value值为null于是执行上面的q.unlink(r)代码，将q的右指针指向r的右指针指向的节点，即就是删除了该level上的7节点的索引节点，如下图所示

       åŽç»­æ“ä½œåŒç†ï¼Œæœ€ç»ˆå°†7节点的索引一一删除完，最终的图下所示

concurrenthashmap1.8源码如何详细解析?

       ConcurrentHashMap在JDK1.8的线程安全机制基于CAS+synchronized实现，而非早期版本的分段锁。

       在JDK1.7版本中，ConcurrentHashMap采用分段锁机制，包含一个Segment数组，每个Segment继承自ReentrantLock，并包含HashEntry数组，每个HashEntry相当于链表节点，虚幻4源码编译用于存储key、value。默认支持个线程并发，每个Segment独立，互不影响。

       对于put流程，与普通HashMap相似，首先定位至特定的Segment，然后使用ReentrantLock进行操作，后续过程与HashMap基本相同。

       get流程简单，通过hash值定位至segment，图虫网源码再遍历链表找到对应元素。需要注意的是，value是volatile的，因此get操作无需加锁。

       在JDK1.8版本中，线程安全的关键在于优化了put流程。首先计算hash值，遍历node数组。若位置为空，则通过CAS+自旋方式初始化。

       若数组位置为空，尝试使用CAS自旋写入数据；若hash值为MOVED，表示需执行扩容操作；若满足上述条件均不成立，则使用synchronized块写入数据，同时判断链表或转换为红黑树进行插入。链表操作与HashMap相同，链表长度超过8时转换为红黑树。

       get查询流程与HashMap基本一致，通过key计算位置，若table对应位置的key相同则返回结果；如为红黑树结构，则按照红黑树规则获取；否则遍历链表获取数据。

ConcurrentHashMap确实很复杂，这样学源码才简单

       ConcurrentHashMap相较于HashMap在实现上更为复杂，主要涉及多线程环境下的并发安全、同步和锁的概念。虽然HashMap的原理主要围绕数组、链表、哈希碰撞和扩容，但在多线程场景下，这些知识还不够，需要对并发和同步有深入理解。

       在实际编程中，HashMap经常被使用，而ConcurrentHashMap的使用频率却相对较低，这使得学习它的门槛变高。学习ConcurrentHashMap之前，关键在于理解HashMap的基本实现，特别是它在非线程安全情况下的操作，如数组初始化和putVal()方法。

       HashMap的线程不安全问题主要表现在数组的懒加载和带if判断的put操作上，这可能导致数据一致性问题。为了解决这些问题，像HashTable和Collections.synchronizedMap()通过synchronized关键字加锁，但会导致性能下降。ConcurrentHashMap引入了CAS（Compare And Swap）技术，比如在initTable()方法中，通过volatile修饰的成员变量保证了数组初始化的线程安全。

       ConcurrentHashMap在数组初始化、下标为空时使用CAS，而在有冲突时切换到synchronized，降低了锁的粒度，以提高效率。扩容是ConcurrentHashMap的难点，需要处理新旧数组的同步迁移问题，通过helpTransfer()方法和transfer()方法来确保线程安全。

       总结来说，学习ConcurrentHashMap不仅是对HashMap知识的扩展，更是进入并发编程世界的重要一步。面试时，如果只问基本数据结构，那可能只需要了解HashMap；但若深入到ConcurrentHashMap，就涉及到了并发编程的核心技术，如CAS、同步和锁的管理。