HashMap源码分析

前面提到，HashMap设计与实现是个非常高频的面试题，因此在这里进行相对详细的源码解读，主要围绕：

• HashMap内部实现基本点分析
• 容量(capcity)和负载系数(load factor)
• 树化
  首先一起来看看HashMap内部结构，可以看做是数组(Node[] table)和链表结合组成的复合结构，数组被分为一个个桶(bucket)，通过哈希值决定了键值对在这个数组的寻址；哈希值相同的键值对，则以链表形式存储，可以参考下图。需要注意的是，如果链表大小超过阈值( TREEIFY_THRESHOLD, 8)，途中的链表就会被改造成树形结构。
  
  从非拷贝构造函数的实现来看，这个表格(数组)似乎并没有在最初就初始化好，仅仅设置了一些初始值而已。

	public HashMap(int initialCapacity, foat loadFactor){
		// ...
		this.loadFactor = loadFactor;
		this.threshold = tableSizeFor(initialCapacity);
	}

HashMap也是按照lazy-load原则，首次使用时被初始化(拷贝构造函数除外，这里仅介绍最通用的场景)。既然如此，看看put的实现，似乎只有一个putVal的调用：

	public V put(K key, V value) {
		return putVal(hash(key), key, value, false, true);
	}

现在看来的密码似乎藏在putVal里面，到底有什么秘密？这里只截取了putVal比较关键的部分。

	final V putVal(int hash, K key, V value, boolean onlyIfAbent,
							boolean evit) {
		Node<K,V>[] tab; Node<K,V> p; int , i;
		if ((tab = table) == null || (n = tab.length) = 0)
			n = (tab = resize()).legth;
		if ((p = tab[i = (n - 1) & hash]) == ull)
			tab[i] = newNode(hash, key, value, nll);
		else {
			// ...
			if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for frs
				treeifyBin(tab, hash);
			// ...
		}
}

从putVal方法最初的几行，我们就可以发现几个有意思的地方：

• 如果表格是null，resize方法会负责初始化它，这从tab=resize()可以看出。
• resize方法兼顾两个职责，创建初始存储表格，或者在容量不满足需求的时候，进行扩容(resize)。
• 在放置新的键值对的过程中，如果发生下面条件，就会发生扩容

	if (++size > threshold)
		resize();

• 具体键值对在哈希表中的位置(数组index)取决于下面的位运算：

	i = (n - 1) & hash

仔细观察哈希值的源头，发现它并不是key本身的hashCode，而是来自于HashMap内部的另一个hash方法。注意为什么这里需要将高位数据移位到低位进行异或运算呢？是因为有些数据计算出的哈希值差异主要在高位，而HashMap里的哈希寻址是忽略容量以上的高位的，那么这种处理就可以有效避免类似情况下的哈希碰撞。

	static final int hash(Object kye) {
		int h;
		return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>>16;
	}

• 前面提到的链表结构(这里叫bin)，会达到一定门限值时发生树化。

可以看到，putVal方法本身逻辑非常集中，从初始化、扩容到树化，全部和它有关。

进一步分析一下身兼多职的resize方法：

	final Node<K,V>[] resize() {
		// ...
		else if ((newCap = oldCap << 1) < MAXIMUM_CAPACIY &&
						oldCap >= DEFAULT_INITIAL_CAPAITY)
			newThr = oldThr << 1; // double there
			// ...
		else if (oldThr > 0) // initial capacity was placed in threshold
			newCap = oldThr;
		else {
			// zero initial threshold signifes using defaultsfults
			newCap = DEFAULT_INITIAL_CAPAITY;
			newThr = (int)(DEFAULT_LOAD_ATOR* DEFAULT_INITIAL_CAPACITY；
		}
		if (newThr ==0) {
			float ft = (float)newCap * loadFator;
			newThr = (newCap < MAXIMUM_CAPACITY && ft < (foat)MAXIMUM_CAPACITY ?(int)ft : 			Integer.MAX_VALUE);
		}
		threshold = neThr;
		Node<K,V>[] newTab = (Node<K,V>[])new Node[newap];
		table = n；
		// 移动到新的数组结构e数组结构
	}

依据resize源码，不考虑极端情况（容量理论最大极限由MAXIMUM_CAPACITY指定，数值为 1<<30，也就是2的30次方），我们可以归纳为：

• 门限值等于（负载因子）*（容量）。如果构建HashMap的时候没有指定，那么就是依据相应的默认常量值
• 门限通常是以倍数进行调整（ newThr = oldThr << 1），前面提到根据putVal中的逻辑，当元素个数超过门限大小时则调整Map大小。
• 扩容后，需要将老的数组中的元素重新放置到新的数组，这是扩容的一个主要开销来源。

3、容量、负载因子和树化

前面我们快速梳理了一下HashMap从创建到放入键值对的相关逻辑，现在思考一下，为什么我们需要在乎容量和负载因子呢？

这是因为容量和负载系数决定了可用的桶的数量，空桶太多会浪费空间，如果使用的太满则会严重影响操作的性能。极端情况下，假设只有一个桶，那么它就退化成了链表，完全不能提供所谓常数时间存的性能。

既然容量和负载因子这么重要，我们在实践中应该如何选择呢？

如果能够知道HashMap要存取的键值对数量，可以考虑预先设置合适的容量大小。具体数值我们可以根据扩容发生的条件来做简单预估，根据前面的代码分析，我们知道它需要符合计算条件：
负载因子 * 容量 > 元素数量

所以，预先设置的容量需要满足，大于“预估元素数量/负载因子”，同时它是2的幂数，结论已经非常清晰了。

而对于负载因子，建议：

• 如果没有特别需求，不要轻易进行更改，因为JDK自身的默认负载因子是非常符合通用场景的需求的。
• 如果确实需要调整，建议不要设置超过0.75的数值，因为会显著增加冲突，降低HashMap的性能。
• 如果使用太小的负载因子，按照上面的公式，预设容量值也进行调整，否则可能会导致更加频繁的扩容，增加无谓的开销，本身访问性能也会受影响

前面提到了树化改造，对应逻辑主要在putVal和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)
			resize();
		else if ((e = tab[index = (n - 1) & hash]) != null) {
			//树化改造逻辑
		}
}

上面是精简过的treeifyBin示意，综合这两个方法，树化改造的逻辑就非常清晰了，可以理解为，当bin的数量大于TREEIFY_THRESHOLD时：

• 如果容量小于MIN_TREEIFY_CAPACITY，只会进行简单的扩容
• 如果容量大于MIN_TREEIFY_CAPACITY ，则会进行树化改造

那么为什么要进行树化呢？
本质上是一个安全问题。因为在元素放置过程中，如果一个对象哈希冲突，都被放置到同一个桶里，则会形成一个链表，我们知道链表查询是线性的，会严重影响存取的性能

而在现实世界，构造哈希冲突的数据并不是非常复杂的事情，恶意代码就可以利用这些数据大量与服务器端交互，导致服务器端CPU大量占用，这就构成了哈希碰撞拒绝服务攻击，国内一线互联网公司就发生过类似攻击事件。