HashMap底层实现原理
引用：https://juejin.cn/post/6844903767033249806
目前存在的问题：
1，链表，红黑树间的转换 还没看明白
jdk1.7 HashMap 底层实现是 table数组加上链表结构，jdk1.8 HashMap底层实现是 Node数组加上链表/红黑树
因为jdk1.8引入了红黑树的概念，所以数据用Node(节点)这个称呼更合适一写，但是内部成员变量并没有变化
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
.......
}
HashMap关键属性：
DEFAULT_INITIAL_CAPACITY：Table数组的默认初始容量16
MAXIMUM_CAPACITY：Table数组最大长度，默认为1 << 30，2^30 = 1073741824。
DEFAULT_LOAD_FACTOR：负载因子，当总元素数 > 数组长度 * 负载因子时，Table数组将会扩容，默认为0.75。
TREEIFY_THRESHOLD：树化阈值，当单个Table内Node数量超过该值，则会将链表转化为红黑树，默认为8（但是实际情况并不一定链表长度达到了这个值就会转红黑树）
UNTREEIFY_THRESHOLD：链化阈值，当扩容期间单个Table内Entry数量小于该值，则将红黑树转化为链表，默认为6。(
为什么链转树时阀值是8，但是树转链时阀值为6呢？就是防止某一个接近阀值的链表出现频繁的增加删除,如果阀值一样的话就会频繁的树链转换很影响效率)
MIN_TREEIFY_CAPACITY：最小树化阈值，当Table所有元素超过改值，才会进行树化（为了防止前期阶段频繁扩容和树化过程冲突）。 这个值是64
size：Table数组当前所有元素数。
threshold：下次扩容的阈值（数组长度 * 负载因子）
HashMap的put操作：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
一，首先跟进hash(key)方法
static final int hash(Object key) {
int h;
//如果key为null的话就把这个table放在数组的0号位置，如果不为null就取key的hash值然后无符号右移16位与
key的hash值进行位异或运算
这样做的目的是为了让高位的数字也参加运算，可以使数组上的数据散列更均匀尽量不要形成链表
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//jdk1.4时候的做法是取key的hash值然后和数组的长度取模运算，但是取模运算效率太低了
二，跟进putVal(hash(key), key, value, false, true)方法
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)
//2.1 hashmap采用懒加载的方式，第一次put的时候才初始化容量
n = (tab = resize()).length;
//这里n = tab.length
if ((p = tab[i = (n - 1) & hash]) == null)
//通过hash算法获取到第i位置的table，如果为null就把当前值赋给table[i]
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果tab[i = (n - 1) & hash]) 存在值判断新值与旧值是否相等
//先判断hash值是因为两个对象相等的话hash值一定相等，hash值相等两个对象不一定相等，hash值不想等，两个对象一定不相等
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p; //把p的值赋给e
//如果Node p 处是否是存在树状结构，如果存在调用putTreeVal方法
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果不是TreeNode，则就是链表，遍历并与输入key做命中碰撞
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//jdk1.8中hashmap采用尾插法，如果当前链表中无数据，说明已经在链表尾部，则直接添加
p.next = newNode(hash, key, value, null);
//判断链表的长度是否达到转红黑树的阀值，执行treeifyBin逻辑
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//但是在这一步不一定会转成红黑树，会判断一下数组的长度是否超过的64位，如果没有
//则不会转红黑树，而是扩容，扩容是一举两得的事情（增加容量，减少链表长度）
treeifyBin(tab, hash);
break;
}
//判断是否存在相同的key值，如果存在break走下面的覆盖逻辑
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//这一步实际上是把p的下一位赋值给p，然后一直for循环直到循环到下一位为空为止
p = e;
}
}
//这一步就是覆盖操作，把原来的vale赋值成新的value，返回旧的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//判断数组中数据是否超过阀值，超过的话会扩容
//threshold初始值为0，所以map第一次put的时候会进行一次容量检测
if (++size > threshold)
//resize方法
resize();
afterNodeInsertion(evict);
return null;
}
三，跟进resize() 方法
final Node<K,V>[] resize() {
//保留旧的hash表
Node<K,V>[] oldTab = table;
//旧的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧的阀值（数组长度*0.75）
int oldThr = threshold;
//新的容量，新的阀值
int newCap, newThr = 0;
if (oldCap > 0) {
//
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//这一步实际上是判断是要初始化数组还是扩容
//先把旧的容量的两倍赋值给新的容量，然后判断新的容量是否超过了hashmap的最大容量，且老的容量大于默认容量
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新的阀值也扩容两倍
newThr = oldThr << 1; // double threshold
}
//如果旧的阀值大于0那么新的容量等于旧的阀值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//否则根据默认容量和默认容量*负载因子计算
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//创建新的数组
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
//遍历数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果此处只有唯一一个数据，则重新计算hash值，并放入新的链表中
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//判断是否是红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//这一步jdk1.8中的hashmap分别用两个链表表示头部和尾部巧妙的解决了闭环死锁的问题
//在向新的数组中迁移旧链表时，通过特定的取索引运算，我们会发现一个规律，就是旧链表中的数据
//在新链表中的位置要么就是原来的索引，要么就是原来的索引+原来数组的长度，jdk1.8巧妙的运用了这个规律
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//遍历数组下的每一个链表
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
//对旧链表重新计算索引位置时索引没有改变的数据的头部
loHead = e;
else
loTail.next = e;
//对旧链表重新计算索引位置时索引没有改变的数据的尾部
loTail = e;
}
else {
if (hiTail == null)
//对旧链表重新计算索引位置时索引等于原索引+原数组长度的数据的头部
hiHead = e;
else
hiTail.next = e;
//对旧链表重新计算索引位置时索引等于原索引+原数组长度的数据的尾部
hiTail = e;
}
} while ((e = next) != null);
//这一步实际上就是利用上面的规律把旧链表迁移到新链表中
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
三, hsahmap的get方法
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//首先判断是不是第一个
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
//一直循环，直到找到key值相等的
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
四，hashmap的remove方法
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//当程序走到这一步的时候 node = e 就是要删除的节点，node = e = p.next
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
tab[index] = node.next;
else
//就是把链断开，然后把p.next指针指向node的下一个位置
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
五，关于jdk1.7中hashmap在扩容时出现的闭环死锁的问题
闭环死锁就是链表的两个节点相互引用，类似于：A->B->C->A, 这样掉用next的时候下一位总会有值，所以就会出现死循环
jdk1.7中hashmap的resize方法
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
transfer(newTable, rehash);
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
transfer方法
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) { // A
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
e.next = newTable[i];
newTable[i] = e;
e = next;
//这三行代码实际上是把原来的链表反着插入到新的数组中
假设某一时刻同时有两个线程都走到了上述代码//A处，
此时：
oldTable[]:
...
table a->b->c->...->null
....
newTable[]:
...
newTable null
...
若有一个线程先抢到cpu的时间片，那么这个线程执行一段时间可能会出现下面这中情况
oldTable[]:
...
table a->null
....
newTable[]:
...
newTable c->b->a->null
...
然后另一个线程抢到了cpu的时间片，会从//A处接着往下执行，他实际上会把newTable[i] = a
oldTable[]:
...
table a->null
....
newTable[]:
...
newTable a->c->b->a->null
...
显然此时newTable中的链表已经形成了闭环
扫一扫
25万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
