HashMap的关键性源代码进行解读
文章目录
HashMap的关键性源代码进行解读
HashMap是Java中用来存储键值对的一个类，实现了Map接口。在实际应用中使用非常广泛，因此对其源码的解读和理解也非常重要。下面我将结合HashMap的源码，深入讲解HashMap的实现细节和背后的实现原理。
HashMap的底层数据结构是数组和链表（或红黑树）的结合体，具有快速的插入、查询、删除等操作，时间复杂度通常为O(1)。这是因为HashMap内部利用哈希函数将键映射到数组的下标位置，使得根据键查找值变得非常高效。但是，如果哈希函数设计不好或者哈希冲突过多，就会导致查找效率下降。
在HashMap中，哈希冲突指的是不同的键通过哈希函数映射到了同一个数组下标位置。解决哈希冲突的方式是：当多个不同的键映射到同一个数组下标位置时，将它们存储在同一个链表（或红黑树）中，称之为“桶”。
关于哈希函数的设计，HashMap使用了Java中的hashCode()方法，将键转换成对应的哈希值。对于相同的键，hashCode()方法返回的哈希值是相同的，但是对于不同的键，哈希值不一定不同，因此在映射到数组下标位置时可能会出现冲突。因此，在HashMap中，还需要额外判断键值是否相等。
下面是HashMap中常用的方法以及其实现细节：
put(key, value)
put(key, value)：将键值对添加进HashMap中。先通过哈希函数计算键的哈希值，然后将键值对存储到对应的桶中。如果桶中已有相同的键，则更新对应的值。如果桶中的元素数量过多（大于等于树化阈值）且该桶未被树化，则将该桶转化为红黑树。
public V put(K key, V value) {
return 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)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == 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))))
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)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
get(key)
get(key)：根据键来获取值。先通过哈希函数计算键的哈希值，然后找到对应桶中的链表（或红黑树），再逐一遍历链表（或查找红黑树），直到找到对应的键值对。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
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 {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
resize()
resize()：当HashMap中的元素数量超过容量和加载因子的乘积时，需要进行扩容。先将容量扩大为原来的两倍，然后将原有的键值对重新hash放到新的桶中。
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) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
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;
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
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;
}
以上就是HashMap的实现细节和背后的实现原理。从以上源码中我们可以了解到，在设计一个高效的哈希表时需要充分考虑哈希函数的设计、哈希冲突的处理以及扩容等问题。同时，也需要合理利用链表、红黑树等数据结构来实现高效的查找操作。
使用HashMap需要注意以下几个问题或场景
使用HashMap需要注意以下几个问题或场景：
- 线程安全：HashMap是非线程安全的，若多个线程同时对同一个HashMap进行操作可能会导致数据不一致的问题。可以使用ConcurrentHashMap实现线程安全。
- 键值类型：HashMap要求键和值必须为引用类型，不能是基本数据类型，需要使用对应的包装类。
- 哈希冲突：HashMap的效率取决于哈希函数的设计和哈希冲突的处理，若哈希函数设计不好或者哈希冲突过多，可能会导致查找效率下降。
- 加载因子：加载因子是指HashMap中实际存储元素占容量的比例，默认为0.75。若加载因子设置过大，可能会导致哈希冲突增多；若设置过小，则会浪费空间。
- 选择合适的初始容量：初始容量太小会导致频繁扩容，而容量过大则会浪费空间。可以通过计算预估量来确定初始容量。
HashMap的不足或限制包括：
- 效率受键的哈希函数影响：HashMap在使用哈希函数将键映射到桶时，若哈希函数设计不好，可能会导致哈希冲突过多，从而影响HashMap的效率。
- 遍历元素无序：HashMap中元素的存储是无序的，因此遍历HashMap时无法保证元素的顺序。
- 占用空间较大：由于需要存储键值对以及哈希表信息，相比于普通的数组或链表，HashMap占用空间较大。
- 线程不安全：HashMap是非线程安全的，需要在多线程环境下使用时进行同步控制，或者使用线程安全的ConcurrentHashMap。
- 对null值的处理：HashMap的键和值都可以为null，但是需要特别注意键为null时的处理，因为其对应的哈希值为0，若哈希函数不做特殊处理，会导致该键值对存储在第一个桶中。
HashMap线程不安全体现
HashMap线程不安全体现在多个线程同时进行写操作时，可能会导致HashMap的内部状态被破坏，导致数据不一致的问题。比如，在下面的代码中，多个线程通过put方法向同一个HashMap中添加元素：
public class HashMapConcurrencyDemo {
public static void main(String[] args) {
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 1000; i++) {
new Thread(() -> {
for (int j = 0; j < 100; j++) {
map.put(j, UUID.randomUUID().toString());
}
}).start();
}
}
}
在上述代码中，启动了1000个线程并发地对同一个HashMap进行put操作，每个线程都向Map中添加100个元素。由于HashMap是非线程安全的，多个线程操作同一个HashMap可能会导致其中的元素被覆盖或者丢失。
另外，在读写并发场景中，由于HashMap的迭代器不支持并发修改，如果同时进行读和写操作，可能会导致ConcurrentModificationException异常。例如：
public class HashMapConcurrencyDemo {
public static void main(String[] args) throws InterruptedException {
Map<Integer, String> map = new HashMap<>();
for (int i = 0; i < 10; i++) {
map.put(i, "value" + i);
}
new Thread(() -> {
Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
Integer key = iterator.next();
System.out.println(Thread.currentThread().getName() + " removing key " + key);
map.remove(key);
}
}).start();
Thread.sleep(1000);
for (int i = 0; i < 10; i++) {
System.out.println(Thread.currentThread().getName() + " reading value " + map.get(i));
}
}
}
在上述代码中，启动了一个线程对HashMap进行迭代并删除元素，同时在主线程中读取Map中的元素。由于HashMap的迭代器不支持并发修改，会导致ConcurrentModificationException异常抛出。
综上，在多线程环境下，若多个线程同时对同一个HashMap进行写操作或者同时进行读写操作，都有可能导致数据不一致的问题，需要使用线程安全的ConcurrentHashMap或者在代码中进行同步控制来解决问题。
HashMap的扩缩容细节
当HashMap中的元素个数超出其容量和装载因子的乘积时，HashMap就会进行扩容。在扩容的过程中，HashMap会重新计算每个元素在扩容后所对应桶的位置，并将元素分摊到不同的桶中。具体的细节如下：
- 扩容时，HashMap 的容量会变为原来的两倍
- 扩容后，原来的所有元素需要重新计算在新的 HashMap 中的索引位置，并放到新的位置中。这个操作称为 rehash，rehash 过程中，会遍历数组并计算每个元素在新数组中的位置，最后把元素放到新位置中
- 扩容完成后，原来的数组中的元素需要释放掉（原来的数组成为垃圾）
- 扩容期间其他线程如果要读取该 HashMap 中的元素，则可能会出现在旧表和新表中发生数据不一致的情况。在JDK1.8中，HashMap使用了一种更加高效的方式进行扩容，称为“基于哈希桶迁移”的方式（原文是"Tree bins were not used yet"）。这种方式不需要像之前一样进行复制和重建，而是通过记录迭代器当前的index和是否走过的大小让元素的搬移是逐个进行，这样就避免了多线程冲突的问题
需要注意的是，扩容是一项比较耗费性能的操作，所以如果可以预测 HashMap 的元素数量，应该在创建 HashMap 时设置其初始容量，避免在后续使用过程中频繁扩容。
参考资料：
[1]
[2]
