jdk源码之ConCurrentHashMap源码注释

时间 2019-11-13

标签 jdk 源码 concurrenthashmap 注释栏目 Java 繁體版

原文原文链接

并发包里面ConcurrentHashMap是一个使用频率，面试频率都是用到比较高的。今天咱们就剖析一下ConCurrentHashMap的源码。咱们仍是使用场景驱动的方式去分析。java

构建函数

可是发现构造函数进去之后就是一个无参的构造，没什么特别的。node

2.分析put流程面试

put流程是整个ConCurrentHashMap的精华部分,里面淋漓尽致的使用了分段加锁的思想。缓存

3.分析get流程安全

Get是一个读流程，采用的也是无锁化方式，可是方法调的底层的unsafe的方法保证了可见性。整个ConCurrentHashMap的性能很高。并发

ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();
//剖析写数据流程
map.put("test","zhangsan");
//剖析读数据流程
map.get("test")

接着咱们分析一下put的方法，这个方法很是重要。体现了整个ConCurrentHashMap的设计精髓。Put点进去之后是这个方法
public V put(K key, V value) {
//重要，点进去之后继续分析
    return putVal(key, value, false);
}


final V putVal(K key, V value, boolean onlyIfAbsent) {
//若是key或者value其中一个null，就报空指针异常
    if (key == null || value == null) throw new NullPointerException();
//取hash值，可是咱们注意的是，这儿并非直接用的key的hashCode值。
//而是调用了spred方法。
//spread里的关键代码是(h ^ (h >>> 16)) & HASH_BITS;
//用当前的hashCode值向右移了16位，而后再作异或
//这样操做的出来的值都保留着着hashCode的高低16位的特征，减小hash冲突
//因此咱们这儿要知道。这儿的hash值不是直接用的hashCode
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
//若是当前的tab里面没有数据
        if (tab == null || (n = tab.length) == 0)
//初始化table,而后进去下一轮循环
            tab = initTable();
//进入下一轮循环之后走到这儿。
//return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
//这儿就是计算index的位置，使用tabAt的方法查找对应位置的数据
//若是对应位置的数据是null，说明咱们要插入的这个位置目前尚未数据
//注意这儿使用的是unsafe的getObjectVolatile，也就是说，这个是具备可见性的
//若是并发的时候有人修改了这个值，对这个操做也是课件。
//若是有同窗看过我以前分析过《从硬件层面聊聊synchonzied和volatile》
//应该知道volatile这儿至关因而加了load屏障，在获取数据的时候，若是在无效队列里面发
//现数据无效，就会从新加载。
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//若是当前位置没有元素，直接就经过cas进行插入元素。
//cas操做的代码是
//return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
//其实这个cas操做在硬件层面是加锁的，因此这儿实际上是线程安全的。这点你们必定
//要知道。
//那么这儿咱们还能够继续分析一下，若是这儿同时两个线程并发进来操做
//必然有一个成功的，一个是失败了，成功的，固然就添加了数据了。
//其实这个地方分段加锁的思想已经出来了，由于咱们分析指导
//针对表的一个位置，咱们采用的cas的机制，这个时候，只有针对同一个位置
//才会插入失败。可是其他的位置照样能够进行cas的操做。换句话说一个位置一把锁
//由于是for循环，因此失败了的那个确定再次循环。
//可是由于这个位置已经有数据了。因此代码不走这儿了。
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
//若是插入成功，那么直接就结束退出。
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
//若是是针对同一个位置插入数据，那么代码就会走到这儿
//走到这儿就直接加了一把锁，而这个锁就是针对这个位置的node
//其实这儿也就体现了分段加锁的思想。一个Node就一把锁
            synchronized (f) {
          //f其实就是前面要加锁的时候，获取出来的node
         //其实若是代码走到这儿，表明的就是tabAt(tab, i) == f
         //可是这儿还要继续判断就是为了一个严谨
         //由于就怕中间有人修改过这个f这个node
  if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
//若是插入的key和value
//key是同样的而且value不为空
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
//直接就覆盖
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }

//代码走到这儿，只能说明是
//key不同，只不过是巧了，虽然key不同
//可是通过hash运算之后，当前key定位了一个
//已经有数据的位置上。
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
//直接就在当前node上挂载 一个node节点
//注意，一个节点上挂载的节点超过8个
//就会变化为红黑树
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
//挂载成功之后就退出
                                break;
                            }
                        }
                    }
//若是当前定位到的Node已经变成是红黑树
//那么就选择使用红黑树的方式插入数据
                    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) {
//若是是散列表上面挂了8个以上的节点
//那么就把当前列表变成红黑树，提高查询效率
                if (binCount >= TREEIFY_THRESHOLD)
//变成红黑树
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
//计算node上挂载的节点个数
    addCount(1L, binCount);
    return null;
}



private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    while ((tab = table) == null || tab.length == 0) {
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    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;
}


上面咱们分析了写入数据的时候加锁的思想，接下来咱们分析一下，ConcurrentHashMap
读数据的时候又是什么状况？
public V get(Object key) {
    Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
    //计算位置
int h = spread(key.hashCode());
//这个条件判断，若是table里是有数据的，而且根据当前
//key计算出来的位置也是有数据的
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (e = tabAt(tab, (n - 1) & h)) != null) {

          //若是是hash值相同
if ((eh = e.hash) == h) {
//若是是key相同
            if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                //那么咱们直接返回当前的value值就行。
return e.val;
        }
        else if (eh < 0)
            return (p = e.find(h, key)) != null ? p.val : null;
//若是代码走到这儿说明，要获取的key的对应
//hash位置确实是有数据的，对应位置的key跟传
//进来的key位置不同,因此遍历列表
        while ((e = e.next) != null) {
//直到遍历到 hash位置同样，key也同样位置。
//而后就把当前value值返回便可。
            if (e.hash == h &&
                ((ek = e.key) == key || (ek != null && key.equals(ek))))
                return e.val;
        }
    }
    return null;
}

整个读的操做，咱们分析实际上是都没有加锁的。
不过咱们注意到map里的元素咱们是靠tabAt(tab, (n - 1) & h)这个方法获取到的。
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
//调用了Unsafe的方法
//还保证了可见性。
    return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

读这个操做保证了可见性，从硬件层面说，就是加了load屏障。因此在读数据的时候必定会嗅探一下，若是发现无效队列里面元素被人修改过。就会发送read消息到总线。从别的高速缓存里或者是主内存里读取数据。不加锁，可是他经过volatile读，尽量给你保证读到其余线程修改的最新的值。函数