HashMap的介绍
HashMap是java.util包下的一个存储键值对数据的集合。
它的底层是数组+链表的结构,在JDK1.8以后又引入了红黑树。
/**
* 底层的数组
*/
transient Node<K,V>[] table;
/**
*链表结构
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int 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;
}
// ...
}
HashMap中hash的含义
Object类有一个hashCode方法,它返回一个int类型的值。源码对它的解释是:
- 在同一个Java程序执行过程中,对同一个对象多次调用hashCode方法,返回结果始终相同。
- 如果两个对象根据equals方法是相等的,那么对这两个对象分别调用hashCode方法得到的结果也相等。
- 不一定要求如果两个对象根据 equals 方法是不相等的,那么对这两个对象分别调用hashCode方法必须产生不同的整数结果。
hash值在HashMap中的作用
/**
*通过位运算获取到hash
*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
*根据(n - 1) & hash得到键值对应在table数组的下标
*如果count >=7 会将将整个链表转换为红黑树
*/
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) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// ...
}
HashMap的线程安全问题
JDK1.7
在HashMap执行transfer方法过程中,需要遍历索引数组和每个链表上的节点,并使用头插法将元素转移到新哈希表的头部。
当两个线程同时调用put()方法时,线程一执行transfer可能会导致链表反转,例如A -> B 变成了B -> A。接着,线程二也执行transfer,将A作为当前节点e,B作为下一个节点next。但是此时实际的指向关系是B -> A,这就导致了环形链表的出现。
JDK1.8
JDK1.8采用了尾插法,因此不会出现上述死锁问题,但仍然可能存在数据覆盖的情况(JDK1.7也存在)。
如果两个线程通过hash值计算得到的数组下标相同,且数组该位置为空,那么先执行put操作的线程的数据就会被后一个覆盖。
ConcurrentHashMap的介绍
ConcurrentHashMap是java.util.concurrent包下的一个集合,其底层数据与HashMap的数据结构相同。
与HashMap相比它是线程安全的。
它在JDK1.7使用的是segment加分段锁,segment本身是基于ReentrantLock重入锁实现的加锁和释放锁的操作,这样就能保证多个线程同时访问ConcurrentHashMap时,同一时间只能有一个线程能够操作相应的节点,这样就保证了ConcurrentHashMap的线程安全。
在JDK1.8使用的是CAS+Synchronized来保证线程安全,如果为空则使用 volatile 加 CAS 来初始化,如果容器不为空,则根据存储的元素计算该位置是否为空。如果根据存储的元素计算结果为空则利用 CAS 设置该节点;如果根据存储的元素计算为空不为空,则使用 synchronized。
final V putVal(K key, V value, boolean onlyIfAbsent) {
//key value不为空
if (key == null || value == null) throw new NullPointerException();
//计算hash值
int hash = spread(key.hashCode());
//统计节点长度,以便判断是否需要转为红黑树
int binCount = 0;
//table
for (Node<K,V>[] tab = table;;) {
//f 具体某个节点,i为计算后的tab下标
//fh为hash值的临时存储
Node<K,V> f; int n, i, fh;
//如果当前table为空,初始化这个table
if (tab == null || (n = tab.length) == 0)
tab = initTable();
//如果当前下标的Node为空,说明是第一次插入这个位置
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//那么尝试CAS获取这个位置,并初始化这个节点,属性为hash,key,value
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
//CAS成功,跳出判断
break; // no lock when adding to empty bin
}
//如果hash值==-1,说明需要扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
V oldVal = null;
synchronized (f) {
//如果已经被赋值给过f
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
//如果key冲突就替换
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
//往下继续循环
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
//如果链表是红黑树,那么就执行红黑树的put方法
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
//是否需要转化为红黑树
if (binCount != 0) {
if (binCount >= TREEIFY_THRESHOLD) //TREEIFY_THRESHOLD = 8
//转红黑树
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
总结
HashMap是非线程安全的,在多线程环境下并发操作可能导致死锁以及数据不一致等问题,JDK1.8提升了HashMap的查找效率,避免了头插法导致的死锁,但仍然是非线程安全的。
ConcurrentHashMap是线程安全的,它通过使用分段锁控制缩小了锁的粒度,并且在JDK1.8后使用了CAS和Synchronized来保证它的线程安全。