ConcurrentHashMap源码(JDK1.8)-volatile

JDK1.8的实现

JDK1.8的实现已经摒弃了Segment的概念，而是直接用Node数组+链表+红黑树的数据结构来实现，并发控制使用Synchronized和CAS来操作，整个看起来就像是优化过且线程安全的HashMap，虽然在JDK1.8中还能看到Segment的数据结构，但是已经简化了属性，只是为了兼容旧版本。

volatile关键字

ConcurrentHashMap是线程安全，它的线程安全与volatile关键字有很大关系。所以要先介绍volatile关键字

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：

1. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2. 禁止进行指令重排序。

可见
为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到内存。如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

内存屏障

1. 在每个volatile写操作的前面插入一个StoreStore屏障；
2. 在每个volatile写操作的后面插入一个StoreLoad屏障；
3. 在每个volatile读操作的后面插入一个LoadLoad屏障；
4. 在每个volatile读操作的后面插入一个LoadStore屏障。
   

成员变量

// 默认最大的容量 
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;
// 和hashMap一样，负载因子
private static final float LOAD_FACTOR = 0.75f;
// 和HashMap一样，链表转换为红黑树的阈值，默认是8
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转换链表的阀值，默认是6
static final int UNTREEIFY_THRESHOLD = 6;
// 进行链表转换最少需要的数组长度，如果没有达到这个数字，只能进行扩容
static final int MIN_TREEIFY_CAPACITY = 64;
// table扩容时, 每个线程最少迁移table的槽位个数
private static final int MIN_TRANSFER_STRIDE = 16;
// 感觉是用来计算偏移量和线程数量的标记
private static int RESIZE_STAMP_BITS = 16;
// 能够调整的最大线程数量
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 记录偏移量
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// 值为-1, 当Node.hash为MOVED时, 代表着table正在扩容
static final int MOVED     = -1;
// TREEBIN, 置为-2, 代表此元素后接红黑树
static final int TREEBIN   = -2;
// 感觉是占位符，目前没看出来明显的作用
static final int RESERVED  = -3;
// 主要用来计算Hash值的
static final int HASH_BITS = 0x7fffffff; 
// 节点数组
transient volatile Node<K,V>[] table;
// table迁移过程临时变量, 在迁移过程中将元素全部迁移到nextTable上
private transient volatile Node<K,V>[] nextTable;
// 基础计数器
private transient volatile long baseCount;
// table扩容和初始化的标记，不同的值代表不同的含义，默认为0，表示未初始化
// -1: table正在初始化;小于-1，表示table正在扩容；大于0，表示初始化完成后下次扩容的大小
private transient volatile int sizeCtl;
// table容量从n扩到2n时, 是从索引n->1的元素开始迁移, transferIndex代表当前已经迁移的元素下标
private transient volatile int transferIndex;
// 扩容时候，CAS锁标记
private transient volatile int cellsBusy;
// 计数器表，大小是2次幂
private transient volatile CounterCell[] counterCells;

Node<K,V>

// Node与HashMap中的Node主要区别就是val和next使用volatile修饰保证并发的可见性，还多了一个find(int h, Object k)内部类方法
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; }
    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)));
    }

    /**
     * Virtualized support for map.get(); overridden in subclasses.
     */
    // 通过hash值和key来寻找
    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)