1 类注释
我们从类注释上大概可以得到如下信息：
- 所有的操作都是线程安全的，我们在使用时，无需再加锁；
- 多个线程同时进行put、remove等操作时并不会阻塞，可以同时进行，和HashTable不同，HashTable在操作时，会锁住整个Map;
- 迭代过程中，即使Map结构被修改，也不会抛ConcurrentModificationException异常；
- 除了数组+链表+红黑树的基本结构外，新增了转移节点，是为了保证扩容时的线程安全的节点；
- 提供了很多Stream流式方法，比如说：forEach、search、reduce等等。
从类注释中，我们可以看出ConcurrentHashMap和HashMap相比，新增了转移节点的数据结构，
至于底层如何实现线程安全，转移节点的具体细节，暂且看不出来，接下来我们细看源码。
2 结构
看ConcurrentHashMap源码，我们会发现很多方法和代码和HashMap很相似，有的同学可能会问，为什么不继承HashMap呢？
继承的确是个好办法，但尴尬的是，ConcurrentHashMap都是在方法中间进行一些加锁操作，也就是说加锁把方法切割了，继承
就很难解决这个问题。
ConcurrentHashMap和HashMap两者的相同之处：
- 数组、链表结构几乎相同，所以底层对数据结构的操作思路是相同的（只是思路相同，底层实现不同）;
- 都实现了Map接口，继承了AbstractMap抽象类，所以大多数的方法也都是相同的，
HashMap有的方法，ConcurrentHashMap几乎都有，所以当我们需要从HashMap切换
到ConcurrentHashMap时，无需关心两者之间的兼容问题。
不同之处： - 红黑树结构略有不同，HashMap的红黑树中的节点叫做TreeNode,TreeNode不仅仅有属性，还维护着红黑树的结构，比如说查找，新增等等；
ConcurrentHashMap中红黑树被拆分成两块，TreeNode仅仅维护的属性和查找功能，新增了TreeBin,来维护红黑树结构，并负责根节点的加锁和解锁； - 新增ForwardingNode(转移）节点，扩容的时候会使用到，通过使用该节点，来保证扩容时的线程安全。
3 put
ConcurrentHashMap在put方法上的整体思路和HashMap相同，但在线程安全方面写了很多保障的代码，我们先来看下大体思路：
- 如果数组为空，初始化，初始化完成之后，走2;
- 计算当前槽点有没有值，没有值的话，cas创建，失败继续自旋（for死循环）,直到成功，槽点有值的话，走3;
- 如果槽点是转移节点（正在扩容）,就会一直自旋等待扩容完成之后再新增，不是转移节点走4;
- 槽点有值的，先锁定当前槽点，保证其余线程不能操作，如果是链表，新增值到链表的尾部，如果是红黑树，使用红黑树新增的方法新增；
- 新增完成之后check需不需要扩容，需要的话去扩容。
具体源码如下：
final V putVal(K key, V value, boolean onlylfAbsent){
if(key==null|value==null)
throw new NullPointerException();
//计算hash
int hash = spread(key.hashCode());
int binCount = 0;
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
//table是空的，进行初始化
if(tab==nullll(n=tab.length)==0)
tab=initTable()
//如果当前索引位置没有值，直接创建
else if ((f = tabAt(tab,i=(n-1)&hash))==null){
//cas在i位置创建新的元素，当i位置是空时，即能创建成功，结束for自循，否则继续自放
if(casTabAt(tab,i,null,new Node<K,v>(hash,key,value,null)))
break;
}
else if ((fh = f.hash) == MOVED)
//no lock when adding to empty bin
//如果当前槽点是转移节点，表示该槽点正在扩容，就会一直等待扩容完成
//转移节点的hash值是固定的，都是MOVED
tab = helpTransfer(tab, f);
//槽点上有值的
else {
V oldVal=null;
//锁定当前槽点，其余线程不能操作，保证了安全
synchronized(f){
//这里再次判断i索引位置的数据没有被修改
//binCount被赋值的话，说明走到了修改表的过程里面
if(tabAt(tab,i)==f){
//链表
if(fh>=0){
binCount=1;
for(Node<K,v>e=f;++binCount){
//值有的话，直接返回
if(e.hash==hash&&
((ek=e.key)==key
(ek!=null&key.equals(ek)))){
oldVal=e.val;
if(!onlylfAbsent)
e.val=value;
break;
}
Node<K,v>pred=e;
//把新增的元素赋值到链表的最后，退出自旋
if((e.next)==null){
pred.next=new Node<K,v>(hash,key,value,null);
break;
}
}
}
//红黑树，这里没有使用TreeNode,使用的是TreeBin,TreeNode只是红黑树的一个
//TreeBin持有红黑树的引用，并且会对其加锁，保证其操作的线程安全
else if (f instanceof TreeBin){
Node<K,V>p;
binCount=2;
//满足if的话，把老的值给oldVal
//在putTreeVal方法里面，在给红黑树重新着色旋转的时候
//会锁住红黑树的根节点
if((p=((TreeBin<K,v)f).putTreeVal(hash,key,value))!=null){
oldVal=p.val;
if(!onlylfAbsent)
p.val=value;
}
}
}
}
if (binCount != 0) {
//链表是否需要转化成红黑树
if(binCount>=TREEIFY_THRESHOLD)
treeifyBin(tab, i)
if(oldVal!=null)
return oldVal;
//这一步几乎走不到。槽点已经上锁，只有在红黑树或者链表新增失败的时候
//才会走到这里，这两者新增都是自旋的，几乎不会失败
break;
}
}
}
//check容器是否需要扩容，如果需要去扩容，调用transfer方法去扩容
//如果已经在扩容中了，check有无完成
addCount(1L,binCount);
return null;
}
源码中都有非常详细的注释，就不解释了，我们重点说一下，ConcurrentHashMap在put过程中，采用了哪些手段来保证线程安全。
3.1 数组初始化时的线程安全
数组初始化时，首先通过自旋来保证一定可以初始化成功，然后通过CAS设置SIZECTL变量的值，
来保证同一时刻只能有一个线程对数组进行初始化，CAS成功之后，还会再次判断当前数组是否已经初始化完成，
如果已经初始化完成，就不会再次初始化，通过自旋+CAS+双重
check等手段保证了数组初始化时的线程安全，源码如下：
//初始化table,通过对sizeCtl的变量赋值来保证数组只能被初始化一次
private final Node<K,V>[] initTable(){
Node<K,V>[] tab; int sc
//通过自旋保证初始化成功
while((tab=table)==null||tab.length==0)
//小于0代表有线程正在初始化，释放当前CPU的调度权，重新发起锁的竞争
if((sc=sizeCtl)<0)
Thread.yield();
//CAS赋值保证当前只有一个线程在初始化，-1代表当前只有一个线程能初始化
//保证了数组的初始化的安全性
else if (U.compareAndSwaplnt(this, SIZECTL, sc,-1)){
try{
//很有可能执行到这里的时候，table已经不为空了，这里是双重check
if((tab=table)==null||tab.length==0){
//进行初始化
int n=(sc>0)?sc:DEFAULT_CAPACITY;
Node<K,V>[] nt=(Node<K,V>[])new Node<?,?>[n];
table = tab = nt ;
sc=n-(n>>2);
}
} finally {
sizeCtl=SC;
}
break;
}
}
return tab;
}
此时为了保证线程安全，做了四处优化:
- 通过自旋死循环保证一定可以新增成功。
在新增之前，通过for(Node<K,V>[]tab=table;;)这样的死循环来保证新增一定可以成功，
一旦新增成功，就可以退出当前死循环，新增失败的话，会重复新增的步骤，直到新增成功为止。 - 当前槽点为空时，通过CAS新增。
Java这里的写法非常严谨，没有在判断槽点为空的情况下直接赋值，因为在判断槽点为空和赋值的瞬间，
很有可能槽点已经被其他线程赋值了，所以我们采用CAS算法，能够保证槽点为空的情况下赋值成功，
如果恰好槽点已经被其他线程赋值，当前CAS操作失败，会再次执行for自旋，再走槽点有值的put流程，这里就是自旋+CAS的结合。 - 当前槽点有值，锁住当前槽点。
put时，如果当前槽点有值，就是key的hash冲突的情况，此时槽点上可能是链表或红黑树，我们通过锁住槽点，来保证同一时刻只会有一个线程能对槽点进行修改
//销定当前槽点，其余线程不能操作，保证了安全
synchronized(f){
- 红黑树旋转时，锁住红黑树的根节点，保证同一时刻，当前红黑树只能被一个线程旋转
lockRoot();
try{
root = balancelnsertion(root, x);
}finally{
unlockRoot();//在旋转之前，锁住红黑树的根节点
}
///获得根节点的写锁
private final void lockRoot(){
//cas写LOCKSTATE的状态，如果是0,就写入1,表示被占用锁
//如果锁定失败，将一直竞争，直到得到为止
if (!U.compareAndSwapint(this,LOCKSTATE,O,WRITER))
contendedLock();// offload to separate method
}
private final void unlockRoot() {
lockState = 0;
}
通过以上4点，保证了在各种情况下的新增（不考虑扩容的情况下）,都是线程安全的，通过
自旋+CAS+锁三大姿势，实现的很巧妙，值得我们借鉴。
3.3 扩容时的线程安全
ConcurrentHashMap的扩容时机和HashMap相同，都是在put方法的最后一步检查是否需要扩容，
如果需要则进行扩容，但两者扩容的过程完全不同，ConcurrentHashMap扩容的方法叫做transfer,
从put方法的addCount方法进去，就能找到transfer方法，transfer方法的主要思路是：
- 首先需要把老数组的值全部拷贝到扩容之后的新数组上，先从数组的队尾开始拷贝;
- 拷贝数组的槽点时，先把原数组槽点锁住，保证原数组槽点不能操作，成功拷贝到新数组时，把原数组槽点赋值为转移节点
- 这时如果有新数据正好需要put到此槽点时，发现槽点为转移节点，就会一直等待，所以在扩容完成之前，该槽点对应的数据是不会发生变化的
- 从数组的尾部拷贝到头部，每拷贝成功一次，就把原数组中的节点设置成转移节点；
- 直到所有数组数据都拷贝到新数组时，直接把新数组整个赋值给数组容器，拷贝完成。
关键源码如下：
//扩容主要分2步，第一新建新的空数组，第二移动拷贝每个元素到新数组中去
//tab:原数组，nextTab:新数
private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab)
//老数组的长度
int n=tab.length,stride;
if((stride=(NCPU>1)?(n>>>3)/NCPU:n)<MIN_TRANSFER_STRIDE)
stride=MIN_TRANSFER_STRIDE;//subdivide range
//如果新数组为空，初始化，大小为原数组的两倍，n<<1
if(nextTab==null){//initiating
try {
Node<K,V>[]nt=(Node<K,V>[])new Node<?,?>[n<<1];
nextTab=nt;
} catch(Throwable ex){//try to cope with OOME
sizeCtl=Integer.MAX_VALUE;
return;
}
nextTable=nextTab;
transferlndex=n;
}
//新数组的长度
//代表转移节点，如果原数组上是转移节点，说明该节点正在被扩容
ForwardingNode<K,v>fwd= ew ForwardingNode<K,v>(nextTab);
boolean advance = true;
boolean finishing=false;//to ensure sweep before committing nextTab
//无限自旋，i的值会从原数组的最大值开始，慢慢递减到0
for(inti=0,bound=0;;){
Node<K,V>f;int fh;
while(advance){
int nextlndex,nextBound;
//结束循环的标志
if(--i>=bound||finishing)
advance = false;
//已经拷贝完成
else if ((nextlndex = transferlndex) <=0){
i=-1;
advance = false;
}
//每次减少i的值
else if (U.compareAndSwapInt
(this, TRANSFERINDEX, nextIndex,
nextBound = (nextIndex > stride ?
nextIndex - stride : 0))) {
bound = nextBound;
i = nextIndex - 1;
advance = false;
}
}
//if任意条件满足说明拷贝结束了
if (i < 0 || i >= n || i + n >= nextn) {
int sc;
//所以此处直接赋值，没有任何问题。
if(finishing){
nextTable=null;
table=nextTab;
sizeCtl=(n<1)-(n>>>1);
return;
}
if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
return;
finishing = advance = true;
i = n; // recheck before commit
}
}
else if ((f = tabAt(tab, i)) == null)
advance = casTabAt(tab, i, null, fwd);
else if ((fh = f.hash) == MOVED)
advance = true; // already processed
else {
synchronized (f) {
if (tabAt(tab, i) == f) {
Node<K,V> ln, hn;
if (fh >= 0) {
int runBit = fh & n;
Node<K,V> lastRun = f;
for (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(Node<K,V>p=f;p!=lastRun;p=p.next){
int ph=p.hash;K pk=p.key;Vpv=p.val
if((ph&n)==0)
hn=new Node<K,v>(ph,pk,pv,hn);
else
hn = new Node<K,V>(ph, pk, pv, hn);
}
//在新数组位置上放置拷贝的
setTabAt(nextTab,i,In);
setTabAt(nextTab,i+n,hn);
//在老数组位置上放上ForwardingNode节点
//put时，发现是ForwardingNode节点，就不会再动这个节点的数据了
setTabAt(tab,i,fwd);
advance = true
}
//红黑树的拷贝
else if (f instanceof TreeBin){
//红黑树的拷贝工作，同HashMap的内容，代码忽略
....
//在老数组位置上放上ForwardingNode节点
}
}
}
}
}
}
扩容中的关键点，就是如何保证是线程安全的，小结有如下几点：
- 拷贝槽点时，会把原数组的槽点锁住；
- 拷贝成功之后，会把原数组的槽点设置成转移节点，这样如果有数据需要put到该节点时，
发现该槽点是转移节点，会一直等待，直到扩容成功之后，才能继续put,可以参考put方法中的helpTransfer方法； - 从尾到头进行拷贝，拷贝成功就把原数组的槽点设置成转移节点。
- 等扩容拷贝都完成之后，直接把新数组的值赋值给数组容器，之前等待put的数据才能继续put。
扩容方法还是很有意思的，通过在原数组上设置转移节点，put时碰到转移节点时会等待扩容成
功之后才能put的策略，来保证了整个扩容过程中肯定是线程安全的，因为数组的槽点一旦被
设置成转移节点，在没有扩容完成之前，是无法进行操作的。
4 get
ConcurrentHashMap读的话，就比较简单，先获取数组的下标，然后通过判断数组下标的key是否和我们的key相等，
相等的话直接返回，如果下标的槽点是链表或红黑树的话，分别调用相应的查找数据的方法，整体思路和HashMap很像，
源码如下
public V get(Object key){
Node<K,v>[]tab;Node<K,v>e,p;int n,eh;K ek;
//计算hashcode
int h = spread(key.hashCode();
//不是空的数组& 并且当前索引的槽点数据不是空的
//否则该key对应的值不存在，返回null
if ((tab = table) != null & (n = tab.length)>0 &&
(e=tabAt(tab,(n-1)&h))!=null){
/槽点第一个值和key相等，直接返回
if((eh=e.hash)==h){
if((ek=e.key)==key||(ek!=null&key.equals(ek)))
return e.val;
}
//如果是红黑树或者转移节点，使用对应的find方法
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;
}
5 总结
分段来保证了线程安全，是平时面试时的重中之重，大家可以尝试 debug 来调试一下源码
扫一扫
316
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
