Java集合系列---ConcurrentHashMap源码解析

ConcurrentHashMap是Java并发容器的一员，jdk1.8以后的基本的数据结构和HashMap相似，也是选用了数组+链表/红黑树的结构，在jdk1,.7以前则是采用了分段锁的技术。ConcurrentHashMap所有操作都是线程安全的，但获取操作不必锁定，并且不支持以某种防止所有访问的方式锁定整个表。
它主要是在桶的入口节点加上Segent节点，用于判断该节点是否能进入

1 继承关系

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
    implements ConcurrentMap<K,V>, Serializable {

可以看出它实现了ConcurrentMap接口

2 基本属性

    private static final int MAXIMUM_CAPACITY = 1 << 30;//表的最大容量
    private static final int DEFAULT_CAPACITY = 16;//默认表的大小
    static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;//最大数组大小
    private static final int DEFAULT_CONCURRENCY_LEVEL = 16;//决定Segment数组的大小并发级别
    private static final float LOAD_FACTOR = 0.75f;//默认加载因子
    static final int TREEIFY_THRESHOLD = 8;//这个值是从链表变成红黑树的阀门，如果大于这个值就会转变
    static final int UNTREEIFY_THRESHOLD = 6;// 红黑树节点小于6的时候转链表
    static final int MIN_TREEIFY_CAPACITY = 64;//转换为红黑树之前还得判断数组的容量是否大于64
    private static final int MIN_TRANSFER_STRIDE = 16;//每次进行转移的最小值
    private static int RESIZE_STAMP_BITS = 16;// 生成sizeCtl所使用的bit位数
    private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;//进行扩容所允许的最大线程数量
    private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS; // 记录sizeCtl中的大小所需要进行的偏移位数
	 static final int MOVED     = -1; // hash for forwarding nodes 表示该节点正在处于扩容工作，内部有个指针指向nextTable
    static final int TREEBIN   = -2; // hash for roots of trees 红黑树的首节点，内部不存key、value，只是用来表示红黑树
    static final int RESERVED  = -3; // hash for transient reservations 当hash桶为空时，充当首结点占位符，用来加锁
    static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash 普通节点的hash计算
    static final int NCPU = Runtime.getRuntime().availableProcessors();//CPU数量
   
      transient volatile Node<K,V>[] table;// 表
   	  private transient volatile Node<K,V>[] nextTable;// 下一个表
	  private transient volatile long baseCount; // 基本计数
      private transient volatile int sizeCtl;// 对表初始化和扩容控制
   	  private transient volatile int transferIndex;// 扩容下另一个表的索引
 	  private transient volatile int cellsBusy; // 旋转锁
      private transient volatile CounterCell[] counterCells;// counterCell表
      //视图
	  private transient KeySetView<K,V> keySet;
      private transient ValuesView<K,V> values;
      private transient EntrySetView<K,V> entrySet;

３ 构造函数

//1. ConcurrentHashMap()型构造函数　　
 　　public ConcurrentHashMap() {}
 　　//说明：该构造函数用于创建一个带有默认初始容量 (16)、加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
 　　//2. ConcurrentHashMap(int)型构造函数
    public ConcurrentHashMap(int initialCapacity) {

        if (initialCapacity < 0) // 初始容量小于0，抛出异常
            throw new IllegalArgumentException();
        int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
                   MAXIMUM_CAPACITY ://找到最接近该容量的幂的二次方
                   tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
        // 初始化
        this.sizeCtl = cap;
    }
 
　　//说明：该构造函数用于创建一个带有指定初始容量、默认加载因子 (0.75) 和 concurrencyLevel (16) 的新的空映射。
 　　//3. ConcurrentHashMap(Map<? extends K, ? extends V>)型构造函数

　　 public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
        this.sizeCtl = DEFAULT_CAPACITY;
        // 将集合m的元素全部放入
        putAll(m);
    }
　　//说明：该构造函数用于构造一个与给定映射具有相同映射关系的新映射。
　　//4. ConcurrentHashMap(int, float)型构造函数
 
　　public ConcurrentHashMap(int initialCapacity, float loadFactor) {
        this(initialCapacity, loadFactor, 1);
    }
　　//说明：该构造函数用于创建一个带有指定初始容量、加载因子和默认 concurrencyLevel (1) 的新的空映射。
　　//5. ConcurrentHashMap(int, float, int)型构造函数
 
    public ConcurrentHashMap(int initialCapacity,
                             float loadFactor, int concurrencyLevel) {
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0) // 合法性判断
            throw new IllegalArgumentException();
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        int cap = (size >= (long)MAXIMUM_CAPACITY) ?
            MAXIMUM_CAPACITY : tableSizeFor((int)size);
        this.sizeCtl = cap;
    }

对于构造函数而言，会根据输入的initialCapacity的大小来确定一个最小的且大于等于initialCapacity大小的2的n次幂,如initialCapacity为15，则sizeCtl为16，若initialCapacity为16，则sizeCtl为16。若initialCapacity大小超过了允许的最大值，则sizeCtl为最大值。
concurrencyLevel只是用来确定sizeCtl的大小，在JDK1.8中的并发控制都是针对具体的桶而言，即有多少个桶就可以允许多少个并发数

4关键的类

Node节点构成每个元素的基本类

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;//key的hash值
        final K key;//key
        volatile V val;//value
        volatile Node<K,V> next;//表示链表中的下一个节点
 }

树节点

static final class TreeNode<K,V> extends Node<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;

(1)parent:表示节点的父节点
(2)left:表示左节点
(3)right:表示右节点
(4)prev:表示前驱节点
(5)red：表示是红树还是黑树
TreeBin 用作树的头结点，只存储root和first节点，不存储节点的key、value值。

static final class TreeBin<K,V> extends Node<K,V> {
        TreeNode<K,V> root;
        volatile TreeNode<K,V> first;
        volatile Thread waiter;
        volatile int lockState;
        // values for lockState
        static final int WRITER = 1; // set while holding write lock
        static final int WAITER = 2; // set when waiting for write lock
        static final int READER = 4; // increment value for setting read lock
}

ForwardingNode在转移的时候放在头部的节点，是一个空节点

static final class ForwardingNode<K,V> extends Node<K,V> {
        final Node<K,V>[] nextTable;
        ForwardingNode(Node<K,V>[] tab) {
            super(MOVED, null, null, null);
            this.nextTable = tab;
        }
}

Segment继承了ReentrantLock锁

static class Segment<K,V> extends ReentrantLock implements Serializable {
        private static final long serialVersionUID = 2249069246763182397L;
        final float loadFactor;
        Segment(float lf) { this.loadFactor = lf; }
    }

5 核心方法

1）put

public V put(K key, V value) {
        return putVal(key, value, false);
    }
   final V putVal(K key, V value, boolean onlyIfAbsent) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {//用来返回节点数组的指定位置的节点的原子操作
                if (casTabAt(tab, i, null,//cas原子操作，在指定位置设定值也就是该桶为空在该桶存入第一个值
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            else if ((fh = f.hash) == MOVED)//当前Map在扩容，先协助扩容，在更新值。
                tab = helpTransfer(tab, f);// 假如桶的头节点为ForwardingNode（转移时的头结点）
            else {
                V oldVal = null;
                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 &&//hash值和key值相同的话直接覆盖
                                    ((ek = e.key) == key ||
                                     (ek != null && key.equals(ek)))) {
                                    oldVal = e.val;
                                    if (!onlyIfAbsent)// 如果已经找到，则根据onlyIfAbsent是否更新
                                        e.val = value;
                                    break;
                                }
                                Node<K,V> pred = e;
                                if ((e = e.next) == null) {//如果不是同样的hash，同样的key的时候，则判断该节点的下一个节点是否为空，为空的话把这个要加入的节点设置为当前节点的下一个节点
                                    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) { //调用putTreeVal方法，将该元素添加到树中去
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                if (binCount != 0) {binCount设置为2，防止转化成二叉树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        // 元素个数增加1，binCount表示当前插入数据所在桶元素序号（1，2...），根据条件决定是否扩容
        addCount(1L, binCount);
        return null;
    }

2）table扩容

新增节点之后，addCount统计tab中的节点个数大于阈值（sizeCtl），会触发transfer，重新调整节点位置。

//x为1，check默认是0，只有hash冲突了传过来的值才会大于1，
//且它的大小是链表的长度（不为红黑树的话）
private final void addCount(long x, int check) {
		//CounterCell[]也是一个继承了锁的对象，指向countcell
        CounterCell[] as; long b, s;
       //如果计数盒子不是空或者cas修改baseCount失败
        //  完成了对baseCount的更新，s = b+x；x = 1;
        if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell a; long v; int m;
            boolean uncontended = true;
            /**
            如果计数盒子是空（尚未出现并发）
            如果随机取余一个数组位置为空
            或者修改这个位置的变量失败（出现并发）
            执行fullAddCount方法，并结束
            **/
            if (as == null || (m = as.length - 1) < 0 ||
                (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                !(uncontended =
                  U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
                fullAddCount(x, uncontended); // 多线程修改baseCount时，竞争失败的线程
                //会执行fullAddCount(x, uncontended),把x的值插入到counterCell类中
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();
        }
        //check大于0说明需要检查是否需要扩容
        if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            /*如果map.size（）大于sizeCtl（达到扩容阈值需要扩容）且
            table不是空，且table的长度小于1 << 30.(可以扩容)
            */
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
                int rs = resizeStamp(n);//根据length得到一个标识
                if (sc < 0) {  
                /*
                如果sc的低16位不等于标识符（校验异常 sizeCtl变化了）
                如果 sc == 标识符 + 1 （扩容结束了，不再有线程进行扩容）
                （默认第一个线程设置 sc ==rs 左移 16 位 + 2，当第一个线程结束扩容了，就
                会将 sc 减一。这个时候，sc 就等于 rs + 1）
                如果 sc == 标识符 + 65535（帮助线程数已经达到最大）
                 如果 nextTable == null（结束扩容了）
                 如果 transferIndex <= 0 (转移状态变化了)
                 结束循环
                */
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)  // 其他线程在初始化，break；
                        break;
                // 如果可以帮助扩容，那么将 sc 加 1. 表示多了一个线程在帮助扩容
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))  
                        transfer(tab, nt);
                }
                /*
                如果不再扩容，将sc更新；标识符左移16位，然后+2,也就是变成一个负数。高16
                位是标识符，低16位初始是2
                */
                else if (U.compareAndSwapInt(this, SIZECTL, sc,    
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    //更新sizeCtl为负数后，开始扩容
                    transfer(tab, null);  
                s = sumCount();
            }
        }
    }