Java面试题HashMap的底层原理和线程安全的替代方案
Posted 一宿君
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java面试题HashMap的底层原理和线程安全的替代方案相关的知识，希望对你有一定的参考价值。
HashMap的底层原理
- 1、HashMap底层数据结构
- 2、HashMap的主要参数都有哪些？
- 3、HashMap的存取原理（put和get方法）
- 4、HashMap默认初始化大小是多少？为什么？为啥都是2的整数次幂？
- 5、HashMap的扩容机制？负载因子？为什么是这么多？
- 6、解决hash冲突的办法有哪些？HashMap用的哪种？
- 7、承接上文，为啥JDK1.8之前用头插法，JDK1.8之后改成了尾插法？
- 8、HashMap为啥是非线程安全？
- 9、如何解决HashMap在多线程环境下存在线程安全问题？
1、HashMap底层数据结构
HashMap是基于哈希表的Map接口的非同步实现，常见的数据结构有堆栈、队列、数组、链表和红黑树，Java中最基本的数据结构有两种，一种是数组，一种是引用。可以说其他所有的数据结构都可以从这两个最基本结构构造而来，当然HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体，所以说HashMap的底层其实就是一个数据结构，被称为哈希表结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，内部就会初始化一个数组。Entry就是数组中的一个元素，每个Map.Entry其实就是一个key-value（键值对数据），每个节点包含当前元素的hash、key、value和指向下一个元素的引用，这就构成了链表。
1.1、JDK1.7和JDK1.8中HashMap的重大区别（很重要）
在此处着重强调，JDK1.7和JDK1.8是对HashMap的重大革新。
当面试官问到HashMap的结构和底层实现原理时，目前来说，HashMap是我们非常常用的数据结构，说是由数组和链表组成的数据结构，没人敢说错。但是在JDK1.8中引入一个新的数据结构，那就是红黑树，所以JDK1.8中HashMap是由数组+链表+红黑树组成的数据结构，元素实例的名称也发生了改变，在JDK1.7中叫Entry，在JDK1.8中叫做Node（即节点），因为红黑树中存储数据全部是节点，实际上是Node<K,V> implements Map.Entry<K,V>，再详细点说，JDK1.8中是数组和链表和红黑树共存的状态，数组定义的时候就是transient Node<K,V>[] table;，所以链表和红黑树使用的也是Node节点了。
1.2、JDK1.8中HashMap涉及的数据结构
1、数组（位桶）
/**
* The table, initialized on first use, and resized as
* necessary. When allocated, length is always a power of two.
* (We also tolerate length zero in some operations to allow
* bootstrapping mechanics that are currently not needed.)
*/
transient Node<K,V>[] table;
2、数组节点元素Node<K,V>实现了Map.Entry接口
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //hash值
final K key; //键
V value; //值
Node<K,V> next; //指向下一个节点的引用
Node(int hash, K key, V value, Node<K,V> 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;
}
//判断两个node是否相等,若key和value都相等，返回true。可以与自身比较为true
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;
}
}
3、红黑树red-black Tree
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父节点
TreeNode<K,V> left; //左子树
TreeNode<K,V> right; //又子树
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red; //颜色属性
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
//返回当前节点的根节点
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
}
1.3、JDK1.8为什么会引入红黑树？
在JDK1.7中HashMap采用的是数组（也称为位桶） + 链表实现的，我们知道数组的长度是有限的，在有限的长度里我们将每一个元素（键值对）通过key进行哈希计算得到对应的hash值，但是hash本身就存在概率性，也就是说两个不同的key，例如“张三”和“三张”通过hash计算有一定的概率会得到相同的hash值，这个时候就引发了一个问题hash碰撞（就是所谓的hash冲突）后续讲解，而链表的引入就是为了解决hash冲突的。
也就是说同一hash值的Node都存储在一个链表中，在JDK1.7中使用头插法（在JDK1.8后使用的尾插法，后续再讲解），也就是说新来的值会占用原有值的位置，而原有值就顺推到了链表的下一个节点，因为写这段代码的作者认为后来插入的值被查找的可能性会更大些，可以提高查找的效率，所以使用了头插法。
那为什么引入红黑树呢？
当位于数组中同一个位置（即链表）中的元素较多时，也就是hash值相同的元素有很多时，全部加在同一个链表上，链表的长度过长，通过key值依次查找的效率会非常低，所以在JDK1.8中引入了红黑树，也就是当数组中某一位置的链表的长度大于等于阈值（8）时，将链表转换为红黑树结构，这样就大大提高了查找的效率。红黑树和链表的结构图如下：
- 链表结构：这种情况下，需要遍历全部元素才行，时间复杂度为O(n)；
- 红黑树结构：其访问性能近似折半查找，时间复杂度为O(logn)。
简单的说下，红黑树是一种近似平衡的二叉查找树，其主要的优点就是“平衡“，即左右子树高度几乎一致，以此来防止树退化为链表，通过这种方式来保障查找的时间复杂度为 O(logn)。
关于红黑树的内容，有太多太多了，主要有一下几个特性：
- 每个节点要么是红色，要么是黑色，但根节点永远是黑色；
- 每个红色节点的两个子节点一定是黑色；
- 红色几点不能连续（也即是，红色节点的子节点和父节点都不能是红色的）；
- 从任一节点到其子树中的每个几点的路径都包含相同数量的黑色节点；
- 所有的叶子节点都是黑色的（注意：这里说的叶子节点其实就是上图中的“NIL”节点）。
JDK1.8中HashMap中链表与红黑树共存的状态：
2、HashMap的主要参数都有哪些？
-
table：也称为位桶，就是hashmap中存储数据的数组；
/** * The table, initialized on first use, and resized as * necessary. When allocated, length is always a power of two. * (We also tolerate length zero in some operations to allow * bootstrapping mechanics that are currently not needed.) */ transient Node<K,V>[] table; -
bin：就是挂在数组上的链表；
-
binCount：表示发生hash冲突的链表上节点的个数，超过阈值8就有转化为红黑树的条件（前提是数组长度要>=64）；
-
TREEIFY_THRESHOLD ：8，链表转化为红黑树的阈值（前提条件是数组容量大于64）
/** * The bin count threshold for using a tree rather than list for a * bin. Bins are converted to trees when adding an element to a * bin with at least this many nodes. The value must be greater * than 2 and should be at least 8 to mesh with assumptions in * tree removal about conversion back to plain bins upon * shrinkage. */ static final int TREEIFY_THRESHOLD = 8; -
TreeNode：红黑树；
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; //父节点 TreeNode<K,V> left; //左子树 TreeNode<K,V> right; //右子树 TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; //颜色属性（红与黑） TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } } -
initialCapacity： table数组的默认初始容量为16；
1<<4 位运算 等于16，因为位运算比乘法运算效率高的多；/** * The default initial capacity - MUST be a power of two. */ static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 -
UNTREEIFY_THRESHOLD : 6，链表长度小于等于6，红黑树就有转化为链表的机会（反树化）；
/** * The bin count threshold for untreeifying a (split) bin during a * resize operation. Should be less than TREEIFY_THRESHOLD, and at * most 6 to mesh with shrinkage detection under removal. */ static final int UNTREEIFY_THRESHOLD = 6; -
MIN_TREEIFY_CAPACITY ：64 ，链表转化为红黑树时的前提条件，table数组的最小长度阈值（或者说即使数组中某个链表的长度达到了阈值8，也不会立即转换结构为红黑树，而是先判断数组长度是否大于64，如果不足64，首先是resize扩容数组大小（扩容2倍）；如果大于64，那些长度大于阈值8的链表结构才会转化为红黑树）
/** * The smallest table capacity for which bins may be treeified. * (Otherwise the table is resized if too many nodes in a bin.) * Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts * between resizing and treeification thresholds. */ static final int MIN_TREEIFY_CAPACITY = 64; -
MAXIMUM_CAPACITY：数组的最大容量，
1<<30 左移30位/** * The maximum capacity, used if a higher value is implicitly specified * by either of the constructors with arguments. * MUST be a power of two <= 1<<30. */ static final int MAXIMUM_CAPACITY = 1 << 30; -
loadFactory：负载因子，默认初始值为0.75f（也就是数组容量的占比为75%），当数组的容量达到
capacity * loadfactory的容量时，会自动resize扩容；/** * The load factor used when none specified in constructor. */ static final float DEFAULT_LOAD_FACTOR = 0.75f;
3、HashMap的存取原理（put和get方法）
3.1、map.put()方法实现原理
当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标索引），如果数组在该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的元素放在链表的头部，先前加入的元素都向后顺延一个位置。如果数组在该位置上没有元素，就直接将该元素放到此数组的该位置上。当系统决定存储HashMap中的key-value（键值对）时，完全没有考虑Entry中value值，仅仅只是根据key来计算并决定每个Entry对象的存储位置。我们完全可以把Map集合中的value当成key的附属，当系统决定了key的存储位置之后，value随之保存在那里即可。
hash(int h)方法根据key的hashCode值重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。对于任意给定的对象，只要它的hashCode()返回值相同，那么程序调用hash(int h)方法所计算得到的hash值总是相同的。我们首先想到的就是把hash值与数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是“模”运算的消耗还是比较大的，在HashMap中是这样做的：调用indexFor(int h，int length) 方法来计算该对象应该保存在table数组的哪个索引处。
- 首先将（k、v）封装到Node节点对象当中；
- 然后底层会调用k的hashCode()方法得出hash值；
- 通过哈希表函数/哈希算法，将hash值转换成数组的下标（用hash值与数组的长度进行取模运算或者位运算），就把Node添加到这个位置上，如果说下标对应的位置上有链表。此时就会拿着k和链表上每个Node节点的k进行equals对比，如果所有的equals方法返回的都是false，那么这个新的节点将被添加到链表的头部（JDK1.7）或末尾（JDK1.8），如果其中有一个equals方法返回的是true，那么这个节点的value值将会被覆盖。
看put方法源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//如果在数组table[(n-1) & hash]处的值为空，则新建一个Node节点，插入在该位置
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//此处表示有hash冲突，开始处理冲突（说明此位置有单向链表存在）
Node<K,V> e; K k;
//检查第一个Node，p是不是要找的hash值，并逐步对每个节点上的key进行equals
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//此处判断是否为树结构，如果是直接将key-value插入树节点中
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//binCount是记录当前链表发生冲突的节点数
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果发生冲突的节点数大于等于阈值8，看是否需要改变冲突节点的存储结构；
//treeifyBin判断当前HashMap数组的长度，如果不足64，
//只对数组table进行resize扩容，暂且不对冲突节点达到8的链表进行结构转换
//当扩容后数组table的长度达到了64后，再将冲突节点数达到8的链表的存储结构转化为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果有相同的key值就结束遍历，直接将该key的value值覆盖掉
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回存在的Value值
return oldValue;
}
}
++modCount;
//如果当前大小大于门限，门限=table初始容量*0.75
if (++size > threshold)
resize();//扩容2倍（新容量 = 旧容量*2）
afterNodeInsertion(evict);
return null;
}
HashMap的treeifyBin()方法源码解析：
final void treeifyBin(Node<K,V>[] tab, int hash) {
//定义几个变量，n是数组长度，index是索引
int n, index; Node<K,V> e;
//这里的tab指的是本HashMap中的数组，n为数字长度，如果数组为null或者数组长度小于64
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//则调用resize()方法直接扩容，不转红黑树
resize();
//否则说明满足转红黑树条件，通过按位与运算取得索引index，并将该索引对应的node节点赋值给e，e不为null时
else if ((e = tab[index = (n - 1) & hash]) != null) {
//定义几个变量，hd代表头节点，tl代表尾节点
TreeNode<K,V> hd = null, tl = null;
do {
//先把e节点转成TreeNode类型，并赋值给p
TreeNode<K,V> p = replacementTreeNode(e, null);
//如果尾节点tl为空，则说明还没有根节点，试想下，这时元素数目都超过8个了，还能没有尾节点么，所以没有尾节点只能说明还没设置根节点
if (tl == null)
//设置根节点，把p赋值给根节点hd
hd = p;
else {
//把tl设置为p的前驱节点
p.prev = tl;
//把p设置为tl的后继节点，这两步其实就是我指向你，你指向我的关系，为了形成双向链表
tl.next = p;
}
//把首节点设置成p后，把p赋值给尾节点tl，然后会再取链表的下一个节点，转成TreeNode类型后再赋值给p，如此循环
tl = p;
//取下一个节点，直到下一个节点为空，也就代表这链表遍历好了
} while ((e = e.next) != null);
//用新生成的双向链表替代旧的单向链表，其实就是把这个数组对应的位置重新赋值成新双向链表的首节点
if ((tab[index] = hd) != null)
//这个方法里就开始做各种比较，左旋右旋，然后把双向链表搞成一个红黑树
hd.treeify(tab);
}
}
3.2、map.get()方法实现原理
- 先调用k的hashCode方法得出哈希值，并通过hash算法计算出当前k在数组中的下标；
- 通过上一步哈希算法计算出数组的下标后，再通过数组下标快速定位到某个位置上，如果这个位置上什么也没有，则返回null；如果这个位置上有单向链表，那么就拿着k与该链表上每一个节点的k进行equals，如果所有的equals方法返回的都是false，则get方法返回null值；如果其中一个equals方法返回的是true，那么此时该节点的value就是我们要找的对应value值了，get方法最终会返回这个value。
看get方法源码：
public V get(Object key) {
Nodejava面试题2-自己整合的