源码学习，边看源码边加注释，边debug，边理解。
基本属性
常量
- DEFAULT_INITIAL_CAPACITY：默认数组的初始容量 - 必须是2的幂。
- MAXIMUM_CAPACITY：数组的最大容量
- DEFAULT_LOAD_FACTOR：哈希表的负载因子0.75
- TREEIFY_THRESHOLD：在一个桶内由树转换成链表的阈值
- UNTREEIFY_THRESHOLD：又树转换成链表的阈值
- MIN_TREEIFY_CAPACITY：在数组长度大于或等于64时才会进行链表转换成树的操作，否则直接扩容
全局变量
- table：数组对象
- size：HashMap大小
- modCount：操作HashMap的总数 for fast-fail
- threshold： 扩容的阈值
- loadFactor：哈希表的负载因子，默认是DEFAULT_LOAD_FACTOR值
数据结构
HashMap的数据结构在jdk1.8之前采用的是数组+链表，jdk1.8之后采用了数组+链表/红黑树的结构，如图：
HashMap的数据结构
如图所示当链表长度大于8时，链表转换成红黑树。
在jdk1.8中存储数据的节点有两种一种是链表节点Node一种是树节点TreeNode：
Node：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
...
TreeNode：
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
...
TeeeNode继承关系.png
通过上面的继承关系我们发现TreeNode是继承自Node的。
如果元素小于8个，链表查询成本高，新增成本低
如果元素大于8个，红黑树查询成本低，新增成本高
常见的使用方式
@Test
public void testHashMap() {
Map<String, Object> map = new HashMap<>();
map.put("1", "1");
map.get("1");
map.size();
}
这是我们使用HashMap最常见的使用方式，下面我就来看下每一步都是怎么实现的。测试代码:
public class HashMapTest {
public static void main(String[] args) {
Map<User, Object> map = new HashMap<>();
for (; ; ) {
map.put(new User(), map.size());
if (map.size() > 1000) {
break;
}
}
map.size();
}
static class User {
@Override
public int hashCode() {
return 1;
}
}
}
构造函数
我们使用HashMap第一步是先创建一个HashMap，从上面的语句来看HashMap继承自Map接口，下面我们开看看new HashMap<>()都做了些什么：
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
原来啥都没干，就只是对一个成员变量赋了一个初值。看来数组的初始化和链表的初始化等都是在后面发生的。
put() 方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
hash() 方法
static final int hash(Object key) {
int h;
// 计算key.hashCode（）并将更高位的散列扩展（XOR）降低。采用位运算主要是是加快计算速度
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
putVal() 方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// 数组对象
Node<K, V>[] tab;
// 通过key值找出对应数组索引位的数据 p = tab[i = (n - 1) & hash]
Node<K, V> p;
// n 表示数组长度， i表示key值在数组上的索引位
int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
// 判断数组是否为null，如果是则调用resize()方法进行初始化
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
// (n-1)&hash= hash%(n-1)，通过该公式找出该值在数组上的索引位。 保证不发生数组越界。
// 如果该索引位为null，则直接将数据放到该索引位
tab[i] = newNode(hash, key, value, null);
else {
Node<K, V> e;
K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
// 表示key完全相同
e = p;
else if (p instanceof TreeNode)
// 桶内已经是红黑树节点
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
else {
// 桶内还是链表节点
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 通过自旋找到尾部节点，并将新数据添加在尾部节点后面
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果链表内的数据已经超过8个则尝试将链表转成红黑树（其实这个时候链表已经有9个节点了，最后一个节点是上一步添加进去的）
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
// key完全相同则走后面的value替换流程
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
// 在key完全相同的情况下，用新数据去覆盖老数据的value值，并返回老数据的value值
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
// 判断如果hash表的总数大于扩容阈值的时候需要进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
putTreeVal() 插入红黑树节点
final TreeNode<K, V> putTreeVal(HashMap<K, V> map, Node<K, V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
// 找到根节点
TreeNode<K, V> root = (parent != null) ? root() : this;
for (TreeNode<K, V> p = root; ; ) {
// dir 表示两个key的比较结果，ph表示p节点的hash值
int dir, ph;
K pk;
if ((ph = p.hash) > h)
// 父节点的hash值大于新节点hash值
dir = -1;
else if (ph < h)
// 父节点的hash值小于新节点hash值
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
// 表示key完全相同
return p;
else if ((kc == null &&
// 判断对key是否实现Comparable接口
(kc = comparableClassFor(k)) == null) ||
// 使用Comparable来比较父节点和新节点的key值大小
(dir = compareComparables(kc, k, pk)) == 0) {
// 这个查找只会执行一次
if (!searched) {
TreeNode<K, V> q, ch;
searched = true;
// 从p的左子树找到对应key的节点
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
// 从p的右子树找到对应key的节点
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
//表示key完全相同的节点
return q;
}
// 使用默认比较器比较两个key的大小
dir = tieBreakOrder(k, pk);
}
TreeNode<K, V> xp = p;
// 自旋找出新节点的父节点
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K, V> xpn = xp.next;
TreeNode<K, V> x = map.newTreeNode(h, k, v, xpn);
// 将新节点放到对应的叶子节点位置
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K, V>) xpn).prev = x;
// 调整树的平衡
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
treeifyBin() 尝试将链表转换成树的方法
final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 检查数组长度如果小于64则不进行红黑树转换，直接进行扩容
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K, V> hd = null, tl = null;
do {
// 将key值对应数组索引位上所有链表节点转换成红黑树节点
TreeNode<K, V> p = replacementTreeNode(e, null);
if (tl == null)
// 树的根节点
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
if ((tab[index] = hd) != null)
// 由链表转换成了红黑树
hd.treeify(tab);
}
}
treeify() 将链表转换成红黑树
final void treeify(Node<K, V>[] tab) {
TreeNode<K, V> root = null;
// for循环遍历链表所有节点
for (TreeNode<K, V> x = this, next; x != null; x = next) {
// 给下一个节点赋值
next = (TreeNode<K, V>) x.next;
x.left = x.right = null;
// 给root节点赋值
if (root == null) {
x.parent = null;
x.red = false;
root = x;
} else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K, V> p = root; ; ) {
int dir, ph;
K pk = p.key;
// 比较root节点和X节点的hash值大小
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
// 将X节点添加到红黑树
TreeNode<K, V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
// 平衡红黑树
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
resize() 扩容方法
final Node<K, V>[] resize() {
// 扩容前的数组
Node<K, V>[] oldTab = table;
// 获取数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 扩容阈值
int oldThr = threshold;
// 扩容后的数组长度和扩容阈值
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
// 如果数组容量已经大于最大容量（1<<30）了那么将不在进行扩容
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 1. 数组长度直接扩容2倍
// 2. 扩容阈值也扩容2倍
newThr = oldThr << 1; // double threshold
} else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 值为0表示还没有初始化，然后给数组初始大小和扩容阈值赋值
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"})
// 根据newCap值创建数组
Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
table = newTab;
// oldTab != null表示是扩容，否则表示是初始化
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
if ((e = oldTab[j]) != null) {
// 将老数组的对应索引位置为NULL，方便GC回收
oldTab[j] = null;
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.7不一样，这里扩容后链表顺序不会发生改变
// 低位桶的头节点
Node<K, V> loHead = null, loTail = null;
// 高位节点高位桶的头节点
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
do {
// 保存下一个节点，待下次循环使用
next = e.next;
// e.hash & oldCap算法可以算出新的节点该分配到那个索引位，
// 这也是为什么数组长度一定要是2的n次幂，否则该算法不可用
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);
// 如果j=0 并且oldCap=16，那么低位桶就是0的索引位，高位桶就是0+16的索引位
if (loTail != null) {
loTail.next = null;
// 设置低索引位的头结点
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
// 设置高索引位的头结点
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
从put方法的源码我们发现：
- HashMap数组的初始化时在put元素的时候发生的
- 发生扩容条件有两个：一个是一个桶内链表数据大于8并且数组长度小于64；HashMap总size大于扩容的阈值。任意满足一个都会发生扩容。
- 在扩容的时候，jdk1.8链表的顺序将不会再发生变化，从而解决了1.8以前链表扩容引发的死循环问题。HashMap中是如何形成环形链表可参考这个
- 数组长度始终是2的n次幂。这样做使我们可以直接使用位运算来计算key的索引位；在扩容的时候可以直接使用位运算来计算高低位索引的节点。
- 链表转换成树的条件是只有当一个桶的元素超过8个并且数组长度大于等于64。
- 链表转换成树只发生在一个桶内，也就是说在HashMap的数据结构中可以一些桶是链表，一些桶是红黑树。
红黑树部分可以参考
get() 方法
public V get(Object key) {
Node<K, V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode() 方法
final Node<K, V> getNode(int hash, Object key) {
Node<K, V>[] tab;
Node<K, V> first, e;
int n;
K k;
// 先根据hash值找到数据所在桶内的根节点（头结点）
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 {
// 自旋查找
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
tableSizeFor() 方法
我们在初始化HashMap的时候，我们传入的初始化大小可能不是2的n次幂。这时我们需要调用tableSizeFor方法找出和cap最接近的2的n次幂的值。
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
HashMap非线程安全的表现
HashMap是一个线程不安全的类，主要表现在：
- 在并发操作下size的统计会出错
- 并发操作下添加节点有可能会丢失数据
- 在并发操作下JDK1.7及以前在扩容的时候链表有可能会形成环形数据结构，一旦形成环形数据结构，Entry的next节点永远不为空，就会产生死循环获取Entry。
HashMap空间效率
HashMap其实是一种空间利用率很低的数据结构，以HashMap<Long，Long>结构为例，我们具体分析一下HashMap空间效率。
有效数据空间
在HashMap<Long，Long>结构中，只有Key和Value所存放的两个长整型数据是有效数据，共16字节（2×8字节）。
实际占用空间
Key和Value这两个长整型数据包装成java.lang.Long对象之后，就分别具有8字节的Mark Word、8字节的Klass指针，再加8字节存储数据的long值。然后这2个Long对象组成Map.Entry之后，又多了16字节的对象头，然后一个8字节的next字段和4字节的int型的hash字段，为了对齐，还必须添加4字节的空白填充，最后还有HashMap中对这个Entry的8字节的引用，这样增加两个长整型数字，实际耗费的内存为(Long(24byte)×2)+Entry(32byte)+HashMap Ref(8byte)=88byte。
空间利用率
空间效率为有效数据空间除以实际占用空间，即16字节/88字节=18%，这确实太低了。
源码
https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases
spring-boot-student-concurrent 工程
layering-cache
为监控而生的多级缓存框架 layering-cache这是我开源的一个多级缓存框架的实现，如果有兴趣可以看一下
