创意电子

标题: 绝了！这是我见过最详细的HashMap源码剖析 [打印本页]

作者: 秃头JAVA 时间: 2021-9-14 06:06
标题: 绝了！这是我见过最详细的HashMap源码剖析
1 概述

HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会主动增长.
HashMap是非线程安全的,只适用于单线程环境,多线程环境可以采用并发包下的concurrentHashMap
HashMap 实现了Serializable接口，因此它支持序列化，实现了Cloneable接口，能被克隆
HashMap是基于哈希表的Map接口的非同步实现.此实现提供全部可选的映射操作,并允许使用null值和null键.此类不保证映射的次序,特别是它不保证该次序恒久不变.
Java8中又对此类底层实现进行了优化，比如引入了红黑树的结构以解决哈希碰撞
2 HashMap的数据结构

在Java中,最基本的结构就是两种,一个是数组,别的一个是模拟指针(引用),全部的数据结构都可以用这两个基本结构来构造,HashMap也不例外.
HashMap实际上是一个"链表散列"的数据结构,即数组和链表的结合体.

HashMap的主结构类似于一个数组,添加值时通过key确定储存位置.
每个位置是一个Entry的数据结构,该结构可组成链表.
当发生冲突时,类似hash值的键值对会组成链表.
这种数组+链表的组合情势大部分环境下都能有不错的性能效果,Java6、7就是这样设计的.
然而,在极度环境下,一组（比如经过精心设计的）键值对都发生了冲突，这时的哈希结构就会退化成一个链表，使HashMap性能急剧降落.
所以在Java8中,HashMap的结构实现变为数组+链表+红黑树

可以看出,HashMap底层就是一个数组结构
数组中的每一项又是一个链表
当新建一个HashMap时,就会初始化一个数组.
3 三大聚集与迭代子

HashMap使用三大聚集和三种迭代子来轮询其Key、Value和Entry对象
public class HashMapExam { public static void main(String[] args) { Map map = new HashMap(16); for (int i = 0; i < 15; i++) { map.put(i, new String(new char[]{(char) ('A'+ i)})); } System.out.println("======keySet======="); Set set = map.keySet(); Iterator iterator = set.iterator(); while (iterator.hasNext()) { System.out.println(iterator.next()); } System.out.println("======values======="); Collection values = map.values(); Iterator stringIterator=values.iterator(); while (stringIterator.hasNext()) { System.out.println(stringIterator.next()); } System.out.println("======entrySet======="); for (Map.Entry entry : map.entrySet()) { System.out.println(entry); } }}4 源码分析

//默认的初始容量16,且实际容量是2的整数幂 static final int DEFAULT_INITIAL_CAPACITY = 1 MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; //负载因子须大于0 if (loadFactor >> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }可以看出该方法是一系列的二进制位操作

a |= b 等同于 a = a|b

逐行分析

int n = cap - 1

给定的cap 减 1,为了避免参数cap本来就是2的幂次方,这样一来,经过后续操作，cap将会变成2 * cap,是不符合我们预期的

n |= n >>> 1

n >>> 1 : n无符号右移1位,即n二进制最高位的1右移一位
n | (n >>> 1) 导致 n二进制的高2位值为1
目前n的高1~2位均为1

n |= n >>> 2

n继续无符号右移2位
n | (n >>> 2) 导致n二进制表现的高3~4位经过运算值均为1
目前n的高1~4位均为1

n |= n >>> 4

n继续无符号右移4位
n | (n >>> 4) 导致n二进制表现的高5~8位经过运算值均为1
目前n的高1~8位均为1

n |= n >>> 8

n继续无符号右移8位
n | (n >>> 8) 导致n二进制表现的高9~16位经过运算值均为1
目前n的高1~16位均为1
可以看出,无论给定cap(cap < MAXIMUM_CAPACITY )的值是多少,经过以上运算,其值的二进制全部位都会是1.再将其加1,这时候这个值一定是2的幂次方.
当然如果经过运算值大于MAXIMUM_CAPACITY,直接选用MAXIMUM_CAPACITY.

至此tableSizeFor怎样保证cap为2的幂次方已经显而易见了,那么问题来了
4.1为什么cap要保持为2的幂次方？

重要与HashMap中的数据存储有关.
在Java8中,HashMap中key的Hash值由Hash(key)方法计得

HashMap中存储数据table的index是由key的Hash值决定的.
在HashMap存储数据时,我们盼望数据能均匀分布,以防止哈希冲突.
自然而然我们就会想到去用%取余操作来实现我们这一构想

取余(%)操作 : 如果除数是2的幂次则等价于与其除数减一的与(&)操作.

这也就表明了为什么一定要求cap要为2的幂次方.再来看看table的index的计算规则：
这也就表明了为什么一定要求cap要为2的幂次方.再来看看table的index的计算规则：

等价于:
index = e.hash % newCap采用二进制位操作&,相对于%,能够提高运算效率,这就是cap的值被要求为2幂次的缘故原由

4.2Node类

static class Node implements Map.Entry { final int hash; final K key; V value; Node next; Node(int hash, K key, V value, Node next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } public final K getKey() { return key; } public final V getValue() { return value; } public final String toString() { return key + "=" + value; } public final int hashCode() { return Objects.hashCode(key) ^ Objects.hashCode(value); } public final V setValue(V newValue) { V oldValue = value; value = newValue; return oldValue; } public final boolean equals(Object o) { if (o == this) return true; if (o instanceof Map.Entry) { Map.Entry e = (Map.Entry)o; if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) return true; } return false; } }Node 类是HashMap中的静态内部类,实现Map.Entry接口.定义了key键、value值、next节点,也就是说元素之间构成了单向链表.
4.3 TreeNode

static final class TreeNode extends LinkedHashMap.Entry { TreeNode parent; // red-black tree links TreeNode left; TreeNode right; TreeNode prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node next) {} // 返回当前节点的根节点 final TreeNode root() { for (TreeNode r = this, p;;) { if ((p = r.parent) == null) return r; r = p; } } }红黑树结构包罗前、后、左、右节点，以及标志是否为红黑树的字段
此结构是Java8新加的
4.4 hash方法

Java 8中的散列值优化函数

只做一次16位右位移异或
key.hashCode()函数调用的是key键值类型自带的哈希函数，返回int型散列值
理论上散列值是一个int型，如果直接拿散列值作为下标访问HashMap主数组的话，考虑到2进制32位带符号的int范围大概40亿的映射空间。只要哈希函数映射得比较均匀松散，一般应用是很难出现碰撞的。
但问题是一个40亿长度的数组，内存是放不下的.HashMap扩容之前的数组初始大小才16,所以这个散列值是不能直接拿来用的.
用之前还要先做对数组的长度取模运算，得到的余数才气用来访问数组下标
源码中模运算就是把散列值和数组长度做一个"与"操作

这也正好表明了为什么HashMap的数组长度要取2的整次幂
因为这样（数组长度-1）正好相当于一个“低位掩码”
“与”操作的结果就是散列值的高位全部归零，只保留低位值，用来做数组下标访问
以初始长度16为例，16-1=15
2进制表现是00000000 00000000 00001111
和某散列值做“与”操作如下，结果就是截取了最低的四位值

但这时候问题就来了,这样就算我的散列值分布再松散,要是只取最后几位的话,碰撞也会很严重
这时候“扰动函数”的代价就体现出来了

右位移16位，正好是32位一半，自己的高半区和低半区做异或，就是为了混合原始hashCode的高位和低位，以此来加大低位的随机性
而且混合后的低位掺杂了高位的部分特征，这样高位的信息也被变相保留下来。
index的运算规则是
e.hash & (newCap - 1)newCap是2的幂,所以newCap - 1的高位全0
若e.hash值只用自身的hashcode,index只会和e.hash的低位做&操作.这样一来,index的值就只有低位参与运算,高位毫无存在感,从而会带来哈希冲突的风险
所以在计算key的hashCode时,用其自身hashCode与其低16位做异或操作
这也就让高位参与到index的计算中来了,即降低了哈希冲突的风险又不会带来太大的性能问题
4.5 Put方法

①.判断键值对数组table是否为空或为null，否则实行resize()进行扩容
②.根据键值key计算hash值得到插入的数组索引i，如果table==null，直接新建节点添加，转向⑥，如果table不为空，转向③
③.判断table的首个元素是否和key一样，如果类似直接覆盖value，否则转向④，这里的类似指的是hashCode以及equals
④.判断table 是否为treeNode，即table 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤
⑤.遍历table，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中实行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可
⑥.插入乐成后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，实行resize()扩容
public V put(K key, V value) {       // 对key的hashCode()做hash       return putVal(hash(key), key, value, false, true); } final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {       Node[] tab; Node p; int n, i;       // 步骤① tab为空则调用resize()初始化创建       if ((tab = table) == null || (n = tab.length) == 0)                   n = (tab = resize()).length;       // 步骤② 计算index,并对null做处理       //tab[i = (n - 1) & hash对应下标的第一个节点          if ((p = tab[i = (n - 1) & hash]) == null)          // 无哈希冲突的环境下,将value直接封装为Node并赋值          tab = newNode(hash, key, value, null);       else {          Node e; K k;          // 步骤③ 节点的key类似,直接覆盖节点          if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k))))             e = p;          // 步骤④ 判断该链为红黑树             else if (p instanceof TreeNode)                // p是红黑树类型，则调用putTreeVal方式赋值             e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value);          // 步骤⑤ p非红黑树类型,该链为链表             else {             // index 类似的环境下             for (int binCount = 0; ; ++binCount) {                   if ((e = p.next) == null) {                      // 如果p的next为空,将新的value值添加至链表后面                      p.next = newNode(hash, key, value, null);                      if (binCount >= TREEIFY_THRESHOLD - 1)                         // 如果链表长度大于8,链表转化为红黑树,实行插入                         treeifyBin(tab, hash);                      break;                   }                   // key类似则跳出循环                   if (e.hash == hash &&  ((k = e.key) == key || (key != null && key.equals(k))))                      break;                   //就是移动指针方便继续取 p.next                      p = e;             }          }          if (e != null) { // existing mapping for key             V oldValue = e.value;             //根据规则选择是否覆盖value             if (!onlyIfAbsent || oldValue == null)                   e.value = value;             afterNodeAccess(e);             return oldValue;          }       }       ++modCount;       // 步骤⑥:超过最大容量,就扩容       if (++size > threshold)          // size大于加载因子,扩容          resize();       afterNodeInsertion(evict);       return null; }在构造函数中最多也只是设置了initialCapacity、loadFactor的值,并没有初始化table,table的初始化工作是在put方法中进行的.
4.6 resize

登录/注册后可看大图

扩容(resize)就是重新计算容量,向HashMap对象里不绝的添加元素,内部的数组无法装载更多的元素时,就需要扩大数组的长度.
当然Java里的数组是无法主动扩容的,方法是使用一个新的数组代替已有的容量小的数组
/**    * 该函数有2种使用环境：1.初始化哈希表 2.当前数组容量过小，需扩容    */final Node[] resize() {       Node[] oldTab = table;       int oldCap = (oldTab == null) ? 0 : oldTab.length;       int oldThr = threshold;       int newCap, newThr = 0;       // 针对环境2：若扩容前的数组容量超过最大值，则不再扩充       if (oldCap > 0) {          if (oldCap >= MAXIMUM_CAPACITY) {             threshold = Integer.MAX_VALUE;             return oldTab;          }          // 针对环境2：若无超过最大值，就扩充为原来的2倍          else if ((newCap = oldCap = DEFAULT_INITIAL_CAPACITY)             //newCap设置为oldCap的2倍并小于MAXIMUM_CAPACITY，且大于默认值, 新的threshold增加为原来的2倍             newThr = oldThr  0) // initial capacity was placed in threshold          // threshold>0, 将threshold设置为newCap,所以要用tableSizeFor方法保证threshold是2的幂次方          newCap = oldThr;       else {             // zero initial threshold signifies using defaults          // 默认初始化          newCap = DEFAULT_INITIAL_CAPACITY;          newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);       }       // 计算新的resize上限       if (newThr == 0) {          // newThr为0，newThr = newCap * 0.75          float ft = (float)newCap * loadFactor;          newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?                   (int)ft : Integer.MAX_VALUE);       }       threshold = newThr;       @SuppressWarnings({"rawtypes","unchecked"})          // 新生成一个table数组          Node[] newTab = (Node[])new Node[newCap];       table = newTab;       if (oldTab != null) {          // oldTab 复制到 newTab          for (int j = 0; j < oldCap; ++j) {             Node e;             if ((e = oldTab[j]) != null) {                   oldTab[j] = null;                   if (e.next == null)                      // 链表只有一个节点，直接赋值                      //为什么要重新Hash呢？因为长度扩大以后，Hash的规则也随之改变。                      newTab[e.hash & (newCap - 1)] = e;                   else if (e instanceof TreeNode)                      // e为红黑树的环境                      ((TreeNode)e).split(this, newTab, j, oldCap);                   else { // preserve order链表优化重hash的代码块                      Node loHead = null, loTail = null;                      Node hiHead = null, hiTail = null;                      Node next;                      do {                         next = e.next;                         // 原索引                         if ((e.hash & oldCap) == 0) {                               if (loTail == null)                                  loHead = e;                               else                                  loTail.next = e;                               loTail = e;                         }                         // 原索引 + oldCap                         else {                               if (hiTail == null)                                  hiHead = e;                               else                                  hiTail.next = e;                               hiTail = e;                         }                      } while ((e = next) != null);                      // 原索引放到bucket里                      if (loTail != null) {                         loTail.next = null;                         newTab[j] = loHead;                      }                      // 原索引+oldCap放到bucket里                      if (hiTail != null) {                         hiTail.next = null;                         newTab[j + oldCap] = hiHead;                      }                   }             }          }       }       return newTab; }

登录/注册后可看大图

4.7 remove方法

remove(key) 方法和 remove(key, value) 方法都是通过调用removeNode的方法来实现删除元素的
final Node removeNode(int hash, Object key, Object value,                            boolean matchValue, boolean movable) {       Node[] tab; Node p; int n, index;       if ((tab = table) != null && (n = tab.length) > 0 &&          (p = tab[index = (n - 1) & hash]) != null) {          Node node = null, e; K k; V v;          if (p.hash == hash &&             ((k = p.key) == key || (key != null && key.equals(k))))             // index 元素只有一个元素             node = p;          else if ((e = p.next) != null) {             if (p instanceof TreeNode)                   // index处是一个红黑树                   node = ((TreeNode)p).getTreeNode(hash, key);             else {                   // index处是一个链表，遍历链表返回node                   do {                      if (e.hash == hash &&                         ((k = e.key) == key ||                            (key != null && key.equals(k)))) {                         node = e;                         break;                      }                      p = e;                   } while ((e = e.next) != null);             }          }          // 分不同情形删除节点          if (node != null && (!matchValue || (v = node.value) == value ||                               (value != null && value.equals(v)))) {             if (node instanceof TreeNode)                   ((TreeNode)node).removeTreeNode(this, tab, movable);             else if (node == p)                   tab[index] = node.next;             else                   p.next = node.next;             ++modCount;             --size;             afterNodeRemoval(node);             return node;          }       }       return null; }4.8 get

/** * 函数原型 * 作用：根据键key，向HashMap获取对应的值 */ map.get(key)； /** * 源码分析 */ public V get(Object key) { Node e; // 1. 计算需获取数据的hash值 // 2. 通过getNode（）获取所查询的数据 ->>分析1 // 3. 获取后，判断数据是否为空 return (e = getNode(hash(key), key)) == null ? null : e.value;}/** * 分析1：getNode(hash(key), key)) */ final Node getNode(int hash, Object key) { Node[] tab; Node first, e; int n; K k; // 1. 计算存放在数组table中的位置 if ((tab = table) != null && (n = tab.length) > 0 &&       (first = tab[(n - 1) & hash]) != null) {       // 4. 通过该函数，依次在数组、红黑树、链表中查找（通过equals（）判断）       // a. 先在数组中找，若存在，则直接返回       if (first.hash == hash && // always check first node          ((k = first.key) == key || (key != null && key.equals(k))))          return first;       // b. 若数组中没有，则到红黑树中寻找       if ((e = first.next) != null) {          // 在树中get          if (first instanceof TreeNode)             return ((TreeNode)first).getTreeNode(hash, key);          // c. 若红黑树中也没有，则通过遍历，到链表中寻找          do {             if (e.hash == hash &&                   ((k = e.key) == key || (key != null && key.equals(k))))                   return e;          } while ((e = e.next) != null);       } } return null;}
在JDK1.7及从前的版本中，HashMap里是没有红黑树的实现的，在JDK1.8中加入了红黑树是为了防止哈希表碰撞攻击，当链表链长度为8时，及时转成红黑树，提高map的效率

如果某个桶中的记录过大的话（当前是TREEIFY_THRESHOLD = 8），HashMap会动态的使用一个专门的treemap实现来更换掉它。这样做的结果会更好，是O(logn)，而不是糟糕的O(n)。它是怎样工作的？
前面产生冲突的那些KEY对应的记录只是简朴的追加到一个链表后面，这些记录只能通过遍向来进行查找。但是超过这个阈值后HashMap开始将列表升级成一个二叉树，使用哈希值作为树的分支变量，如果两个哈希值不等，但指向同一个桶的话，较大的谁人会插入到右子树里。如果哈希值相等，HashMap希望key值最好是实现了Comparable接口的，这样它可以按照次序来进行插入。这对HashMap的key来说并不是必须的，不外如果实现了当然最好。如果没有实现这个接口，在出现严重的哈希碰撞的时候，你就并别指望能获得性能提升了。
这个性能提升有什么用处？比方说恶意的程序，如果它知道我们用的是哈希算法，它大概会发送大量的请求，导致产生严重的哈希碰撞。然后不绝的访问这些key就能明显的影响服务器的性能，这样就形成了一次拒绝服务攻击（DoS）。JDK 8中从O(n)到O(logn)的飞跃，可以有效地防止类似的攻击，同时也让HashMap性能的可预测性轻微加强了一些
/** * 源码分析：resize(2 * table.length) * 作用：当容量不足时（容量 > 阈值），则扩容（扩到2倍） */ void resize(int newCapacity) {    // 1. 保存旧数组（old table）    Entry[] oldTable = table;    // 2. 保存旧容量（old capacity ），即数组长度 int oldCapacity = oldTable.length;    // 3. 若旧容量已经是系统默认最大容量了，那么将阈值设置成整型的最大值，退出       if (oldCapacity == MAXIMUM_CAPACITY) {       threshold = Integer.MAX_VALUE;       return;    }    // 4. 根据新容量（2倍容量）新建1个数组，即新table    Entry[] newTable = new Entry[newCapacity];    // 5. （重点分析）将旧数组上的数据（键值对）转移到新table中，从而完成扩容 ->>分析1.1    transfer(newTable);    // 6. 新数组table引用到HashMap的table属性上 table = newTable;    // 7. 重新设置阈值    threshold = (int)(newCapacity * loadFactor); }  /** * 分析1.1：transfer(newTable); * 作用：将旧数组上的数据（键值对）转移到新table中，从而完成扩容 * 过程：按旧链表的正序遍历链表、在新链表的头部依次插入 */ void transfer(Entry[] newTable) {    // 1. src引用了旧数组    Entry[] src = table;    // 2. 获取新数组的大小 = 获取新容量大小                      int newCapacity = newTable.length;    // 3. 通过遍历旧数组，将旧数组上的数据（键值对）转移到新数组中    for (int j = 0; j < src.length; j++) {          // 3.1 取得旧数组的每个元素          Entry e = src[j];                   if (e != null) {             // 3.2 释放旧数组的对象引用（for循环后，旧数组不再引用任何对象）             src[j] = null;             do {                // 3.3 遍历以该数组元素为首的链表                // 注：转移链表时，因是单链表，故要保存下1个结点，否则转移后链表会断开                Entry next = e.next;                // 3.3 重新计算每个元素的存储位置                int i = indexFor(e.hash, newCapacity);                // 3.4 将元素放在数组上：采用单链表的头插入方式 = 在链表头上存放数据 = 将数组位置的原有数据放在后1个指针、将需放入的数据放到数组位置中                // 即扩容后，大概出现逆序：按旧链表的正序遍历链表、在新链表的头部依次插入                e.next = newTable;                newTable = e;                // 访问下1个Entry链上的元素，云云不断循环，直到遍历完该链表上的全部节点                e = next;                         } while (e != null);          // 云云不断循环，直到遍历完数组上的全部数据元素       }    } }从上面可看出：在扩容resize（）过程中，在将旧数组上的数据转移到新数组上时，转移数据操作 = 按旧链表的正序遍历链表、在新链表的头部依次插入，即在转移数据、扩容后，容易出现链表逆序的环境

设重新计算存储位置后不变，即扩容前 = 1->2->3，扩容后 = 3->2->1

此时若并发实行 put 操作，一旦出现扩容环境，则容易出现环形链表，从而在获取数据、遍历链表时形成死循环（Infinite Loop），即死锁

登录/注册后可看大图

登录/注册后可看大图

登录/注册后可看大图

登录/注册后可看大图

4.9 getOrDefault

getOrDefault() 方法获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值。

登录/注册后可看大图

5 单线程rehash

单线程环境下，rehash无问题

登录/注册后可看大图

6 多线程并发下的rehash

这里假设有两个线程同时实行了put操作并引发了rehash，实行了transfer方法，并假设线程一进入transfer方法并实行完next = e.next后，因为线程调理所分配时间片用完而“停息”，此时线程二完成了transfer方法的实行。此时状态如下。

登录/注册后可看大图

接着线程1被唤醒，继续实行第一轮循环的剩余部分
e.next = newTable[1] = nullnewTable[1] = e = key(5)e = next = key(9)结果如下图所示

登录/注册后可看大图

接着实行下一轮循环，结果状态图如下所示

登录/注册后可看大图

继续下一轮循环，结果状态图如下所示

登录/注册后可看大图

此时循环链表形成，而且key(11)无法加入到线程1的新数组。在下一次访问该链表时会出现死循环。
7 Fast-fail

产生缘故原由

在使用迭代器的过程中如果HashMap被修改，那么ConcurrentModificationException将被抛出，也即Fast-fail计谋。
当HashMap的iterator()方法被调用时，会构造并返回一个新的EntryIterator对象，并将EntryIterator的expectedModCount设置为HashMap的modCount（该变量记录了HashMap被修改的次数）。
HashIterator() {  expectedModCount = modCount;  if (size > 0) { // advance to first entry  Entry[] t = table;  while (index < t.length && (next = t[index++]) == null) ;  }}在通过该Iterator的next方法访问下一个Entry时，它会先查抄自己的expectedModCount与HashMap的modCount是否相等，如果不相等，说明HashMap被修改，直接抛出ConcurrentModificationException。该Iterator的remove方法也会做类似的查抄。该异常的抛出意在提示用户赶早意识到线程安全问题。
线程安全解决方案
单线程条件下，为避免出现ConcurrentModificationException，需要保证只通过HashMap本身或者只通过Iterator去修改数据，不能在Iterator使用竣事之前使用HashMap本身的方法修改数据。因为通过Iterator删除数据时，HashMap的modCount和Iterator的expectedModCount都会自增，不影响二者的相等性。如果是增加数据，只能通过HashMap本身的方法完成，此时如果要继续遍历数据，需要重新调用iterator()方法从而重新构造出一个新的Iterator，使得新Iterator的expectedModCount与更新后的HashMap的modCount相等。
多线程条件下，可使用Collections.synchronizedMap方法构造出一个同步Map，或者直接使用线程安全的ConcurrentHashMap。

作者：JavaEdge.
原文链接：https://blog.csdn.net/qq_33589510/article/details/120184298

欢迎光临创意电子 (https://www.wxcydz.cc/) Powered by Discuz! X3.4