JDK7版本:
数组+Segment+分段锁机制:
1)在ConcurrentHashMap中,定义了一个Segment<K, V>[]数组来将Hash表实现分段存储,从而实现分段加锁;一个Segment可以看作是一个小的HashTable;
2)Segment继承了ReetrantLock,表示Segment是一个可重入锁;
3)执行put操作时首先经过一次hash找到对应的Segment,然后对该Segment加锁即可,再进行第二次hash找要求的value
4)加锁的粒度是一个Segment,同一个Segment的不同链表插入操作还是会相互影响的
缺点:
ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作,效率较低;
由于最新版本已经弃用这个结构,所以不做过多分析;
JDK8版本:
数组+链表+红黑树的实现方式,加锁采用CAS和synchronized实现;
与JDK7版本相比,取消了Segment分段锁机制,调整为对每个数组元素加锁(Node)
同HashMap类似,一个链表长度大于8会将链表转为红黑树,红黑树规模小于6会将红黑树转为链表
构造方法:
//设置初始容量,扩容因子,并发等级,并发等级就是最多允许多少个线程并发
public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
throw new IllegalArgumentException();
if (initialCapacity < concurrencyLevel) { //数组容量不能小于并发等级,因为每条链表都是同步的
initialCapacity = concurrencyLevel;
}
long size = (long)(1.0 + (long)initialCapacity / loadFactor);
int cap = (size >= (long)MAXIMUM_CAPACITY) ?
MAXIMUM_CAPACITY : tableSizeFor((int)size);
this.sizeCtl = cap;
}
插入第一个元素时,如果发现hash表为空,要对hash表进行初始化:
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0) //如果正在进行初始化或正在扩容,让出CPU
Thread.yield();
else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
try {
if ((tab = table) == null || tab.length == 0) {
//如果hash表为空或大小为0,创建一个hash表,大小为自定义或默认大小
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
get:
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
//将key的hash值做了某种变换,为了减少hash冲突
int h = spread(key.hashCode());
//tabAt()方法通过volatile读获取value值,保证不读到脏数据
if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
while ((e = e.next) != null) {
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
put
下面主要看看put方法,是如何处理同步问题的:
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode()); //获取hash值并用spread函数处理
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0) { //如果table为空,初始化table
tab = initTable();
}
//如果table为不为空,但key对应的节点在table中不存在,则将这个节点插入table,不用加锁
//这里通过tabAt方法找到table中,哈希值为hash的链表首节点,并为f赋值,f后面要作为插入操作的锁
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
break;
}
//需要扩容,调用helpTransfer扩容
else if ((fh = f.hash) == MOVED)
tab = helpTransfer(tab, f);
else {
//这个分支下需要将新的元素插入链表或红黑树中,需要用synchronized对插入过程加锁
V oldVal = null;
//注意者里的锁f,它是链表的首节点或树根节点,所以put操作的锁的粒度是一条链表或一棵树,而不是整个table
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
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;
}
}
}
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)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
可以看到,ConcurrentHashMap同样使用了synchronized对插入方法加锁,但是与HashTable锁的粒度较大,插入过程会将所有的链表加锁,而ConcurrentHashMap只会对当前要插入的链表进行加锁,这也是ConcurrentHashMap比HashTable高效的原因