并发编程学习笔记（二十七、ConcurrentHashMap，Java8 ConcurrentHashMap）

目录：

• 属性及内部类
• 构造函数
• 核心方法

属性及内部类

1、属性：

其实说到属性最终要的也无法就是一个hash数组桶，其它核心的属性都是大同小异。

transient volatile Node<K,V>[] table;

2、Node：ConcurrentHashMap存储数据的基本单元。

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;

    Node(int hash, K key, V val, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.val = val;
        this.next = next;
    }

    public final K getKey()       { return key; }
    public final V getValue()     { return val; }
    public final int hashCode()   { return key.hashCode() ^ val.hashCode(); }
    public final String toString(){ return key + "=" + val; }
    /** ConcurrentHashMap不允许更新value **/
    public final V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    public final boolean equals(Object o) {
        Object k, v, u; Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                (k == key || k.equals(key)) &&
                (v == (u = val) || v.equals(u)));
    }

    /**
     * 用于map中的get()方法，子类重写
     */
    Node<K,V> find(int h, Object k) {
        Node<K,V> e = this;
        if (k != null) {
            do {
                K ek;
                if (e.hash == h &&
                    ((ek = e.key) == k || (ek != null && k.equals(ek))))
                    return e;
            } while ((e = e.next) != null);
        }
        return null;
    }
}

Node非常简单，一眼就能看出其底层用链表实现，但只允许查找数据，不允许修改。

3、TreeNode：继承自Node，但内部使用的数据结构是红黑树，当链表长度大于8时就会从Node转换成TreeNode。

4、TreeBin：存储属性结构的容器，也就是TreeNode的容器，提供了一些红黑树的条件和锁的控制。

5、ForwardingNode：支持扩容操作，将已处理的节点和空节点置为ForwardingNode，并发处理时多个线程经过ForwardingNode就表示已经遍历过了。

构造函数

Java8的构造和7类似，且ConcurrentHashMap和HashMap的无参构造也同样使用的是懒加载。

public ConcurrentHashMap() {}

核心方法

1、put()、putVal()：

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();
    // 两次hash，减少hash冲突，可让其均匀分布
    int hash = spread(key.hashCode());
    int binCount = 0;
    // 遍历table
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            // 和HashMap同样的使用懒加载的方式，在用的时候再初始化
            tab = initTable();
        // 如果位置i没有数据
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 使用CAS的方式插入
            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);
        // 若以上条件都不满足，则就是要进行加锁操作
        // 也就是存在hash冲突是，需要锁住链表或红黑树的头节点
        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;
                            // 若是相同的key则会覆盖老的value
                            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) {
                // 若链表长度大于8时，则会转换成红黑树
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 统计size，并检查是否需要扩容
    addCount(1L, binCount);
    return null;
}

putVal的过程其实很清晰，我来简单的总结下：

• 如果还没有初始化则初始化。
• 如果没有hash冲突则直接CAS插入。
• 如果还在进行扩容则先进行扩容。
• 如果存在hash冲突，就先加锁来保证线程安全。
  • 链表就遍历插入到尾端。
  • 红黑树就按照红黑树的结构插入。
• 如果链表长度大于阀值8，则先转换成红黑树，在进入一次循环。
• 如果添加成功后调用addCount()方法统计size，并检查是否需要扩容。

2、initTable()：初始化ConcurrentHashMap存储槽。

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;
}

这段代码虽然看起来简单，但你必须要知道sizeCtl的含义后才能弄明白。

/**
 * 用于控制table初始化和resize的参数。
 * -1：表示正在发生初始化
 * 一个很小的负数（非固定数字）：标识table正在调整大小
 * 0：代表默认状态
 * 16 * 2 ^ n * 0.75：下一次扩容的阀值
 */
private transient volatile int sizeCtl;

说完了sizeCtl后，你就能很轻松的看懂initTable了。

首先当sizeCtl < 0，则表示table正在调整大小，所以当前线程需要让步，也就是让在调整大小的线程先去执行；

然后会CAS的把sc调整为-1，也就是通知别的线程我要去初始化啦；

CAS成功后判断tab是否有值，还是空的话便初始化为默认容量。