9.1 Hashtable与ConcurrentHashMap详解
1.0 Hashtable详解
Hashtable 和HashMap用法是和底层的结构都是数组+链表+红黑树,都是key-value键值对数据的存储,最大的区别就是HashMap线程不安全,Hashtable 线程安全。HashMap当什么时候会发生线程不安全呢?当两个线程同时新增在数组上同一位置的数据时(同一链表数据),两线程同时操作数据可能被冲掉。
1.1 Hashtable线程安全特性
通常让解决线程安全的方式就是 synchronized 和Lock ,Hashtable就是采用的是在方法前面添加synchronized,在put,remove,clone,get 等相关方法前都添加的锁。如下
public synchronized V put(K key, V value)
public synchronized V remove(Object key)
public synchronized Object clone()
public synchronized V get(Object key)
Hashtable实现线程安全方式比较简单,但是效率低。ConcurrentHashMap的效率比较高。
2.ConcurrentHashMap
2.1 1.7线程安全的逻辑
首先,我们来看JDK 1.7中ConcurrentHashMap的底层结构,它基本延续了HashMap的设计,采用的是数组 加 链表的形式。和HashMap不同的是,ConcurrentHashMap中的数组设计 分为大数组Segment和小数组HashEntry ;大数组Segment理解为数据库,每个数据库(Segment)中有很多张表(HashEntry),每个HashEntry中有很多条数据,这些数据是用链表连接的。
Segment本身是基于ReentrantLock重入锁实现的加锁和释放锁的操作,这样就能保证多个线程同时访问ConcurrentHashMap时,同一时间只能有一个线程能够操作相应的节点,这样就保证了ConcurrentHashMap的线程安全。 ConcurrentHashMap的线程安全是建立在Segment加锁的基础上的,所以,我们称它为分段锁或者片段锁。
2.2 1.8线程安全逻辑
重要成员变量
ConcurrentHashMap拥有出色的性能,在真正掌握内部结构时,先要掌握比较重要的成员:
1)LOAD_FACTOR 载因子,默认75%,当table使用率达到75%时,为减少table的hash碰撞,tabel长度将扩容一倍。负载因子计算:元素总个数%table.lengh ;
2)TREEIFY_THRESHOLD:默认8当链表长度达到8时,将结构转变为红黑树。
3)UNTREEIFY_THRESHOLD: 默认6.红里树转变为链表的阈值。
4)MIN_TRANSFER_STRIDE:默认16,table扩容时,每个线程最少迁移table的槽位个数。 MOVED:值为-1,当5)Node.hash为MOVED时,代表着table正在扩容 TREEBIN.置为-2.代表此元素后接红黑树。
6)nextTable:table迁移过程临时变量,在迁移过程中将元素全部迁移到nextTable上。
7) sizeCt:用来标志table初始化和扩容的,不同的取值代表着不同的含义:
7.1)0:table还没有被初始化
7.2)-1:table正在初始化
7.3)小于-1:实际值为resizeStamp(n)<<RESIZESTAMP_ SHIFT+2,表明table正在扩容
7.4)大于0:初始化完成后,代表table最大存放元素的个数,默认为0.75*n
8)transferlndex:table容量从n扩到2n时,是从索引n->1的元素开始迁移,transferlndex代表当前已经迁移的元素下标
9)ForwardinaNode:一个特殊的Node节点,其hashcode=MOVED,代表着此时table正在做扩容操作,扩容期间,若table某个元素为null那么该元素设置为ForwardingNode,当下个线程向这个元素插入数据时,检查hashcode=MOVED.就会帮着扩容。
ConcurrentHashMap由三部分构成,table+链表+红黑树,其中table是一个数组,既然是数组,必须要在使用时确定数组的大小,当table存放的元素过多时,,就需要扩容,以减少碰撞发生次数,本文就讲解扩容的过程。扩容检查主要发生在插入元素(putVal0)的过程:
- 一个线程插完元素后,检查table使用率若超过闻值,调用transfer进行扩容
- 个线程插入数时发table对应元素的hash=MOVED 那么调用helpTransfer协助扩容
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
Node<K,V>[] nextTab; int sc;
if (tab != null && (f instanceof ForwardingNode) &&
(nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
int rs = resizeStamp(tab.length);
while (nextTab == nextTable && table == tab &&
(sc = sizeCtl) < 0) { // 说明还在扩容
//判断是否标志发生变化||扩容结束
if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
//达到最大的帮主线程||判断扩容转移下标是否在调整(扩容结束)
sc == rs + MAX_RESIZERS || transferIndex <= 0)
break;
//将SizeCtrl+1,表示增加一个线程帮做扩容
if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)) {
transfer(tab, nextTab);
break;
}
}
return nextTab;
}
return table;
}
上面helpTransfer写作扩容源码主要事情如下:
1)检查是否扩容完毕;
2)对SizeCtrl=SizeCtrl+1,然后调用transfer真正扩容。
transfer源码
整体步骤就是新建一个nextTab,size是之前的2倍,将table上的非空元素迁移到nextTab上面去。
private final void transfer(ConcurrentHashMap.Node<K,V>[] tab, ConcurrentHashMap.Node<K,V>[] nextTab) {
int n = tab.length, stride;
if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
// subdivide range 每个线程最少迁移16个槽位
stride = MIN_TRANSFER_STRIDE;
// initiating 开始初始化新的nextTab
if (nextTab == null) {
try {
@SuppressWarnings("unchecked")
ConcurrentHashMap.Node<K,V>[] nt = (ConcurrentHashMap.Node<K,V>[])new ConcurrentHashMap.Node<?,?>[n << 1];//扩容2倍
nextTab = nt;
} catch (Throwable ex) { // try to cope with OOME
sizeCtl = Integer.MAX_VALUE;
return;
}
nextTable = nextTab;
transferIndex = n;//更新转移下标
}
int nextn = nextTab.length;
ConcurrentHashMap.ForwardingNode<K,V> fwd = new ConcurrentHashMap.ForwardingNode<K,V>(nextTab);
//是否能够向前推进到下一个周期
boolean advance = true;
// to ensure sweep before committing nextTab 完成状态,如果是,则结束此方法
boolean finishing = false;
for (int i = 0, bound = 0;;) {
ConcurrentHashMap.Node<K,V> f; int fh;
while (advance) {//取下一周期
//本线程处理的区间为[bound,i],范围还没处理完成,那么久继续处理
int nextIndex, nextBound;
if (--i >= bound || finishing)
advance = false;
//目前处理到这里(从大到小,下线),开始找新的一轮的区间
else if ((nextIndex = transferIndex) <= 0) {
i = -1;
advance = false;
}
//这个条件改变的是TRANSFERINDEX的值,从16变成1
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
//nextBound 是这次迁移任务的边界,注意是从后向前
bound = nextBound;//一块区间最小链表的下标
i = nextIndex - 1;//能够处理的最大链表的下标
advance = false;
}
}
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
if (finishing) {
nextTable = null;
//直接把以前的table丢弃了,上面的MOVE等标志全部丢弃,使用新的
table = nextTab;
sizeCtl = (n << 1) - (n >>> 1);//扩大2n-0.5n=1.50n,更新新的容量阈值
return;
}
//表示当前线程迁移完成了
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
//注意此时sc的值不等于sizeCtl,上一步sizeCtl=sizeCtl-1了。这两个对象还是分割的
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
//如果对应位置为null,则将ForwardingNode 放在对应的地方
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
//别的线程已经在处理了,再推进一个下标
else if ((fh = f.hash) == MOVED)
// already processed 推动下一个周期,仍然会检查i与bound是否结束
advance = true;
else {//说明位置上有值了
//需要加锁,防止在向里面放值,在放数据时,也会锁住。比如整个table正在迁移,还没有迁移到这个元素,另外一个线程在操作
synchronized (f) {
if (tabAt(tab, i) == f) {//判断i下标和f是否相同
ConcurrentHashMap.Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;//高位链表和低位链表
ConcurrentHashMap.Node<K,V> lastRun = f;
for (ConcurrentHashMap.Node<K,V> p = f.next; p != null; p = p.next) {
int b = p.hash & n;
if (b != runBit) {
runBit = b;
lastRun = p;
}
}
if (runBit == 0) {
ln = lastRun;
hn = null;
}
else {
hn = lastRun;
ln = null;
}
for (ConcurrentHashMap.Node<K,V> p = f; p != lastRun; p = p.next) {
int ph = p.hash; K pk = p.key; V pv = p.val;
if ((ph & n) == 0)
ln = new ConcurrentHashMap.Node<K,V>(ph, pk, pv, ln);
else
hn = new ConcurrentHashMap.Node<K,V>(ph, pk, pv, hn);
}
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
else if (f instanceof ConcurrentHashMap.TreeBin) {
ConcurrentHashMap.TreeBin<K,V> t = (ConcurrentHashMap.TreeBin<K,V>)f;
ConcurrentHashMap.TreeNode<K,V> lo = null, loTail = null;
ConcurrentHashMap.TreeNode<K,V> hi = null, hiTail = null;
int lc = 0, hc = 0;
for (ConcurrentHashMap.Node<K,V> e = t.first; e != null; e = e.next) {
int h = e.hash;
ConcurrentHashMap.TreeNode<K,V> p = new ConcurrentHashMap.TreeNode<K,V>
(h, e.key, e.val, null, null);
if ((h & n) == 0) {
if ((p.prev = loTail) == null)
lo = p;
else
loTail.next = p;
loTail = p;
++lc;
}
else {
if ((p.prev = hiTail) == null)
hi = p;
else
hiTail.next = p;
hiTail = p;
++hc;
}
}
ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
(hc != 0) ? new ConcurrentHashMap.TreeBin<K,V>(lo) : t;
hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
(lc != 0) ? new ConcurrentHashMap.TreeBin<K,V>(hi) : t;
setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;
}
}
}
}
}
}
其中有两个变量需要了解下:
1)advance:表示是否可以向下一个轮元素进行迁移。
2)finishing:table所有元素是否迁移完成。
大致做了如下事情
1>确定线程每轮许移元素的个数stride.比如讲来一个线程,确定扩容table下标为(ab]之间元素,下一个线程扩容(bc],这里对b-a或者c-b也是中最小值16限制的,也就是说每个线程最少扩容连续16个table的元素,而标志当前许移的下标保存在transferindex里面.
2>检查nextTab是否完成初始化,若没有的话,说明是第一个迁移的线程,先初始化nextTabsize是之前table的2倍。
3>进入while循环查找本轮迁移的table下标元素区间,保存在(boundi]中,注意这里是半开半闭区间。
4>从i->bound开始遍历table中每个元素,这里是从大到小遍历的:
1.若该元素为空,则向该元素标写入ForwardinaNode,然后检查下一个元素,当别的线程向这个元素插入数据时,根据这个标志符知道了table正在被别的线程迁移,在 putVal中就会调用helpTransfer帮着迁移。
2.若该元素的hash=MOVED,代表次table正在处干迁移之中,跳过,按道理不会跑着这里的。
3.否则说明该元素跟着的是一个链表或者是个红里树结构,若hash>0,则说明是个链表,若f instanceof TreeBin,则说明是个红里树结构。
5>链表迁移原理如下;遍历链表每个节点。若节点的f,hashsn== 0成立,则将节点放在i,否则,则将节点放在n+i上面.
迁移前,对该元素进行加锁。遍历链表时,这里使用lastRun变量,保留的是上次hash的值,假如整个链表全部节点f.hash&n==0,那么第二次遍历,只要找到lastRun的值,那么认为之后的节点都是相同值。减少了不必要的fhash&n取值。遍历完所有的节点后,此时形成了两条链表,In存放的是f.hash&n=0的节点,hn存放的是非0的节点,然后将In存放在nextTable第i元素的位置,n+i存放在n+i的位置 。