第三章JUC高并发容器

JUC高并发容器

ArrayList，LinkedList，HashMap都是线程非安全的；Vector，Stack，HashTable，SynchronizedList都是通过Synchronized内置锁实现同步，Synchronized的的并发性还是比较低的。所以延伸出JUC高并发容器。

1、 简介

JUC基于非阻塞算法（Lock Free，无锁编程）提供了一组高并发容器，包括高并发的List、Set、Queue、Map容器。无锁编程主要通过cas算法+volatile关键字实现。
ArrayList—>CopyOnWriteArrayList
Hashset—>CopyOnWriteArraySet基于CopyOnWriteArrayList实现
TreeSet—>ConcurrentSkipListSet基于ConcurrentSkipListMap实现
HashMap—>ConcurrentHashMap
TreeMap—>ConcurrentSkipListMap
ConcurrentLinkedQueue是基于列表实现的单向队列
ConcurrentLinkedDeque是基于链表的双向队列
阻塞队列
ArrayBlockingQueue：基于数组实现的可阻塞的FIFO队列
LinkedBlockingQueue：基于链表实现的可阻塞的FIFO队列
PriorityBlockingQueue：按优先级排序的队列
DelayQueue：按照元素的Delay时间进行排序的队列
SynchronousQueue：无缓冲等待队列

2、CopyOnWriteArrayList

底层实现了写入时拷贝的思想，增删该操作会将底层数组拷贝一份，更改操作在新数组上执行，这时不影响其他线程的并发读，并发读写，互斥写，读写分离

public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        	//获取旧的数组
            Object[] elements = getArray();
            int len = elements.length;
            //拷贝新的数组(这是比较耗时的操作，但是不影响其他读线程)
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //添加新元素
            newElements[len] = e;
            //替换旧数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

get方法的弱一致性
array = 【1】【2】【3】，线程一get方法第一步getArray，此时线程二执行移除【1】并且【2】【3】给到array，但是getArray得到的array仍然是【1】【2】【3】，所以线程一get方法得到的是【1】，但是【1】已经被删除了。
迭代器的弱一致性

public static void main(String[] args) throws InterruptedException {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        Iterator<Integer> iterator = list.iterator();//此时获得的是【1】【2】【3】
        new Thread(()->{
            list.remove(0);
            System.out.println(list);
        }).start();
        Thread.sleep(1000);
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }

然而，这种实现方式也有其缺陷，就是不能在迭代期间调用Iterator.remove()，Iterator.add()操作，否则会抛出UnsupportedOperationException异常。这是因为在进行迭代操作时，CopyOnWriteArrayList是使用原有数据进行迭代的，而在修改操作时，CopyOnWriteArrayList会复制一份数据并在复制的数据上进行修改操作，这就导致了原有数据和迭代器使用的数据不一致，从而引发了异常。以下是一个示例代码，演示了在迭代期间调用Iterator.remove()会抛出UnsupportedOperationException异常：

import java.util.concurrent.CopyOnWriteArrayList;
import java.util.Iterator;

public class CopyOnWriteArrayListDemo {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
        list.add("a");
        list.add("b");
        list.add("c");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("b")) {
                iterator.remove(); // 在迭代期间调用remove()，会抛出异常
            }
        }
    }
}

如果是使用ArrayList实现的List，在迭代期间想要删除元素，可以使用迭代器的remove()方法,如果使用ArrayList的remove()方法会报错，这是因为在进行迭代操作时，会有一个modCount变量记录List结构被修改的次数。而直接调用List的remove()、add()或set()方法会直接修改List结构，导致modCount的值被修改。当下一次使用迭代器遍历List时，会检测到modCount的值已经被修改，迭代器就会抛出ConcurrentModificationException异常，以避免出现数据不一致的情况。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class ArrayListDemo {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()) {
            String item = iterator.next();
            if (item.equals("b")) {
                list.remove(item); // 在迭代期间直接调用List的remove()方法
            }
        }
    }
}

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0) {
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    }
    elementData[--size] = null; // Let gc do its work

    return oldValue;
}

可以看到，ArrayList的remove()方法会先增加modCount的值，然后将指定位置的元素从elementData数组中移除，同时将后面的元素向前移动一个位置，并将size的值减1。当在迭代期间直接调用ArrayList的remove()方法时，由于modCount的值被修改，而Iterator中的expectedModCount的值没有被修改，所以在下一次遍历List时，Iterator会检测到modCount和expectedModCount的值不一致，从而抛出ConcurrentModificationException异常。

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    public boolean hasNext() {
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    public E next() {
        checkForComodification();
        int i = cursor;
        if (i >= size)
            throw new NoSuchElementException();
        Object[] elementData = ArrayList.this.elementData;
        if (i >= elementData.length)
            throw new ConcurrentModificationException();
        cursor = i + 1;
        return (E) elementData[lastRet = i];
    }

    public void remove() {
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();

        try {
            ArrayList.this.remove(lastRet);
            cursor = lastRet;
            lastRet = -1;
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

可以看到，Iterator中的expectedModCount字段用于保存ArrayList的结构被修改时的modCount值，用于在下一次遍历List时检测modCount和expectedModCount的值是否一致。当调用Iterator的remove()方法时，会先检测modCount和expectedModCount的值是否一致，如果不一致，则抛出ConcurrentModificationException异常，否则就将指定位置的元素从ArrayList中移除，并将lastRet、cursor和expectedModCount的值更新。

3、ConcurrentHashMap

3.1 常量

//散列表容量最大值
private static final int MAXIMUM_CAPACITY = 1 << 30;
//散列表默认值
private static final int DEFAULT_CAPACITY = 16;
//并发级别，jdk1.7遗留下来的，1.8只有在初始化的时候用到，不代表并发级别
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
//负载因子，在jdk1.8中ConcurrentHashMap不可以修改
private static final float LOAD_FACTOR = 0.75f;
//树化阈值：链表长度>8并且size>=64树化
static final int TREEIFY_THRESHOLD = 8;
static final int MIN_TREEIFY_CAPACITY = 64;
//红黑树转为链表阈值
static final int UNTREEIFY_THRESHOLD = 6;
//线程迁移数据最小步长，控制线程迁移任务最小区间的
private static final int MIN_TRANSFER_STRIDE = 16;
//扩容相关:计算扩容时生成的一个标识戳
private static int RESIZE_STAMP_BITS = 16;
//65535 表示并发扩容最大线程数
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
//node节点的hash值为-1时，表示当前节点是FWD节点
static final int MOVED     = -1; // hash for forwarding nodes
//node节点的hash值为-2时，表示当前节点已经树化，且当前节点为TreeBin对象，TreeBin对象代理操作红黑树
static final int TREEBIN   = -2; // hash for roots of trees
static final int RESERVED  = -3; // hash for transient reservations
//可以将一个负数通过位与运算后得到正数，但是不是取绝对值
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
//当前系统的cpu数量
static final int NCPU = Runtime.getRuntime().availableProcessors();

3.2成员变量

//散列表，长度一定是2的幂次方
transient volatile Node<K,V>[] table;
//扩容过程中，会将扩容中的新table赋给nextTable保持引用，扩容结束之后这里会被设置为null
private transient volatile Node<K,V>[] nextTable;
//LongAdder中的baseCount，未发生竞争时或者当前LongAdder处于加锁状态中，增量累加到baseCount中
private transient volatile long baseCount;
//cellsBusy 0表示当前LongAdder对象无锁状态，1表示当前LongAdder对象加锁状态
private transient volatile int cellsBusy;
//LongAdder中的cells数组，当baseCount发生竞争后会创建cells数组，线程会通过计算hash值取到自己的cell，将增量累加到指定cell中，总数=sum（cells ）+ baseCount
private transient volatile CounterCell[] counterCells;
/**
sizeCtl<0
1.-1表示当前table正在初始化(有线程在创建table数组)，当前线程需要自旋等待
2.表示当前map正在进行扩容，高16位表示扩容的表示戳，低16位表示(1+nThread)当前参与并发扩容的线程数量
sizeCtl=0 表示创建table数组时，使用DEFAULT_CAPACITY大小
sizeCtl>0
1.如果table未初始化，表示初始化大小
2.如果table已经初始化，表示下次扩容时的触发条件(扩容阈值)
*/
private transient volatile int sizeCtl;
//扩容过程中记录当前进度，所有线程都需要从transferIndex中分配区间任务，去执行自己的任务
private transient volatile int transferIndex;

3.3 静态代码块

 // Unsafe mechanics
private static final sun.misc.Unsafe U;
//表示sizeCtl属性在ConcurrentHashMap中内存偏移地址
private static final long SIZECTL;
//表示transferIndex属性在ConcurrentHashMap中内存偏移地址
private static final long TRANSFERINDEX;
//表示baseCount属性在ConcurrentHashMap中内存偏移地址
private static final long BASECOUNT;
//表示cellBusy属性在ConcurrentHashMap中内存偏移地址
private static final long CELLSBUSY;
//表示cellValue属性在CounterCell中内存偏移地址
private static final long CELLVALUE;
//表示数组第一个元素的偏移地址
private static final long ABASE;
//表示transferIndex属性在ConcurrentHashMap中内存偏移地址
private static final int ASHIFT;
static {
        try {
            U = sun.misc.Unsafe.getUnsafe();
            Class<?> k = ConcurrentHashMap.class;
            SIZECTL = U.objectFieldOffset
                (k.getDeclaredField("sizeCtl"));
            TRANSFERINDEX = U.objectFieldOffset
                (k.getDeclaredField("transferIndex"));
            BASECOUNT = U.objectFieldOffset
                (k.getDeclaredField("baseCount"));
            CELLSBUSY = U.objectFieldOffset
                (k.getDeclaredField("cellsBusy"));
            Class<?> ck = CounterCell.class;
            CELLVALUE = U.objectFieldOffset
                (ck.getDeclaredField("value"));
            Class<?> ak = Node[].class;
            ABASE = U.arrayBaseOffset(ak);
			//表示数组单元占用的空间大小，scale表示Node[]数组中每一个单元所占用空间大小
            int scale = U.arrayIndexScale(ak);
            //判断数组的大小是不是2^n
            if ((scale & (scale - 1)) != 0)
                throw new Error("data type scale not a power of two");
            //numberOfLeadingZeros返回当前数值转为二进制后，从高位到低位有多少连续的0在一块8
            //8=>1000 那么ASHIFI就是28
            //4=>100 那么Integer.numberOfLeadingZeros(scale)就是29，ASHIFT 就是2
           	//node[5]的地址 = ABASE + 5 * scale = ABASE + 5<
            ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
        } catch (Exception e) {
            throw new Error(e);
        }
}

3.4内部类

Node

static class Node<K,V> implements Map.Entry<K,V> {
		/**
			为什么使用final修饰是线程安全的?
			1、基本类型的数据，赋值后被final修饰的变量不能被改变
			2、引用类型的数据，地址不能改变，但是地址中的值可以改变：比如private final List myList = new ArrayList（）中myList.add（"Hello"）允许但是myList =  new List()不可以
			3、使用final修饰之后可以保证其他线程不会修改hash和key
		*/
		//key的hashcode ReHash之后的结果(h ^ (h >>> 16)) & HASH_BITS;
        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;
            //如果entry的key和value都相等的话返回true
            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)));
        }

        /**
         * 当Node变成FWD或者TreeNode会使用.
         */
        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;
        }
}

TreeNode

//TreeNode维护了两个结构：一个是双向链表，一个树结构
 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;

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

        Node<K,V> find(int h, Object k) {
            return findTreeNode(h, k, null);
        }

        /**
         * Returns the TreeNode (or null if not found) for the given key
         * starting at given root.
         */
        final TreeNode<K,V> findTreeNode(int h, Object k, Class<?> kc) {
            if (k != null) {
                TreeNode<K,V> p = this;
                do  {
                    int ph, dir; K pk; TreeNode<K,V> q;
                    TreeNode<K,V> pl = p.left, pr = p.right;
                    if ((ph = p.hash) > h)
                        p = pl;
                    else if (ph < h)
                        p = pr;
                    else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                        return p;
                    else if (pl == null)
                        p = pr;
                    else if (pr == null)
                        p = pl;
                    else if ((kc != null ||
                              (kc = comparableClassFor(k)) != null) &&
                             (dir = compareComparables(kc, k, pk)) != 0)
                        p = (dir < 0) ? pl : pr;
                    else if ((q = pr.findTreeNode(h, k, kc)) != null)
                        return q;
                    else
                        p = pl;
                } while (p != null);
            }
            return null;
        }
}

ForwardingNode

//1、如果当前线程拿到FWD节点，说明正在resize过程中。如果当前线程是写线程那么该线程需要帮助扩容;如果当前线程是读线程会通过find方法去新表中进行查询
//2、占位
 static final class ForwardingNode<K,V> extends Node<K,V> {
 		//新表的引用
        final Node<K,V>[] nextTable;
        ForwardingNode(Node<K,V>[] tab) {
       		//FWD的hash是-1
            super(MOVED, null, null, null);
            this.nextTable = tab;
        }
		//
        Node<K,V> find(int h, Object k) {
            // loop to avoid arbitrarily deep recursion on forwarding nodes
            outer: for (Node<K,V>[] tab = nextTable;;) {
                Node<K,V> e; int n;
                if (k == null || tab == null || (n = tab.length) == 0 ||
                    (e = tabAt(tab, (n - 1) & h)) == null)
                    return null;
                for (;;) {
                    int eh; K ek;
                    if ((eh = e.hash) == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                    if (eh < 0) {
                        if (e instanceof ForwardingNode) {
                            tab = ((ForwardingNode<K,V>)e).nextTable;
                            continue outer;
                        }
                        else
                            return e.find(h, k);
                    }
                    if ((e = e.next) == null)
                        return null;
                }
            }
        }
}

3.5函数

小工具函数

spread
node节点的hash属性 = spread（key.hashcode）

static final int spread(int h) {
	//保证散列表的长度比较小时hashcode可以参与运算(h ^ (h >>> 16))
	//& HASH_BITS将负的hashcode变成正数，在ConcurrentHashMap中负的hashcode有特殊意义表示在扩容或者是树节点
    return (h ^ (h >>> 16)) & HASH_BITS;
}

tabAt
HashMap里面计算元素索引通过hash&(table.length-1)
conHashMap使用cas方法计算table[]地址偏移处的node，优化是使用左移代替乘法运算。

static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
	//ABASE得到数组第一个元素的基地址+i*table数组单元的大小
   return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}

casTabAt
使用cas方法覆盖table[i]处的node。如果c=table[i]的值，则将当前的node变成v

static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
   return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
}

setTabAt
使用cas方法直接table[i] = v

static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
   U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}

resizeStamp
所有的线程只要是将数组从16位扩容到32位得到的戳都是一致的

static final int resizeStamp(int n) {
   return Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));
}

tableSizeFor
返回>=c的并且是2^n次方的数

private static final int tableSizeFor(int c) {
        int n = c - 1;
        n |= n >>> 1;
        n |= n >>> 2;
        n |= n >>> 4;
        n |= n >>> 8;
        n |= n >>> 16;
        return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}

构造方法

延迟创建散列表

public ConcurrentHashMap() {
}

table数组的初始化容量是>=1.5*initialCapacity的2^n的值

public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
         MAXIMUM_CAPACITY :
         tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));
    //sizeCtl>0,table[]没有初始化时-->sizeCtl表示初始化容量
    this.sizeCtl = cap;
}

public ConcurrentHashMap(Map<? extends K, ? extends V> m) {
   this.sizeCtl = DEFAULT_CAPACITY;
   putAll(m);
}

public ConcurrentHashMap(int initialCapacity, float loadFactor) {
   this(initialCapacity, loadFactor, 1);t
}

loadFactor，concurrencyLevel只负责计算初始化容量。concurrencyLevel表示初始化容量必须大于并发级别，loadFactor表示保证了实际的初始化容量为(1.0 + (long)initialCapacity / loadFactor)initialCapacity并且满足2^n的值

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);
     //sizeCtl>0,table[]没有初始化时-->sizeCtl表示初始化容量
     this.sizeCtl = cap;
}

3.6 核心方法

put方法

(1)put方法

    public V put(K key, V value) {
    //onlyIfAbsent为false表示如果散列表中有key-value = key的元素直接替换
        return putVal(key, value, false);
    }

(2)putVal方法

    final V putVal(K key, V value, boolean onlyIfAbsent) {
    	//conHashMap要求key！=null ，value！=null，但是HashMap里面允许key=null
        if (key == null || value == null) throw new NullPointerException();
        //扰动函数，1、保证当散列表长度不大，hashcode高位也可以参与寻址运算2、保证正常节点的hash为正数
        int hash = spread(key.hashCode());
        // binCount 表示当前key-value封装为node插入指定桶位后，在桶位中的所属链表的下标位置，在HashMap里面也有这个字段，判断链表是否需要树化
        //0 表示当前桶位为null，node可以直接放
        //2 表示当前桶位可能已经树化成了红黑树(因为链表的长度是2binCount也是2)        
        int binCount = 0;
        //tab表示散列表数组
        for (Node<K,V>[] tab = table;;) {
        	//f表示桶位的头结点，n表示散列表长度，i表示通过寻址计算之后得到的桶位坐标，fh表示桶位头结点的hash
            Node<K,V> f; int n, i, fh;
0            //case1：第一次插入数据，散列表还没初始化，需要进行初始化
            if (tab == null || (n = tab.length) == 0)
            	//见下面initTable，初始化并没有将第一个元素放入还需要再次自旋插入
                tab = initTable();
            //通过路由寻址算法定位到插入桶位置
            //case2：桶位头结点为空，尝试使用cas将节点插入桶位头结点
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            	//cas成功退出for循环，失败则再次自旋尝试
            	//cas方式 指定数组i桶位为new no5 de，期望值为null
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //case3：前置条件：桶位头节点一定不是null。桶位头结点有值且头结点是FWD，表示当前map正在扩容过程中
            else if ((fh = f.hash) == MOVED)
            //看到当前节点是FWD节点后，当前节点有义务帮助map对象完成数据迁移的工作
                tab = helpTransfer(tab, f);
            //case4：当前桶位可能是链表也可能是红黑树代理节点
            else {
            	//当插入key存在，会将旧值赋值给oldval，返回给put方法调用处
                V oldVal = null;
                //给头元素加锁
                synchronized (f) {
                	//为什么要对比当前头节点是否是之前获取的头结点？
                    if (tabAt(tab, i) == f) {
                    	//Treebin节点的hash为负数
                        if (fh >= 0) {
                        	//1.当前插入key与链表中所有元素的key都不一致时，当前的插入操作追加到链表尾部，binCount表示链表长度；2.当前插入key与链表当中某个元素的key一致时，当前插入操作表示替换，binCount表示冲突位置(binCount-1)
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                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;
                                }
                            }
                        }
                        // 前置条件，该桶位一定不是链表
                        //条件成立，表示当前桶位是红黑树代理节点，如果有冲突的话putTreeVal会返回冲突节点的引用
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            //强制设置binCount为2，因为binCount<=1时有其他含义，所以这里设置了2
                            binCount = 2;
                            //为什么上面已经有synchronized了putTreeVal方法中插入节点自平衡的时候还要加锁?
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                           value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }
                //说明当前桶位不是null，可能是红黑树也可能是链表
                if (binCount != 0) {
                	//如果是红黑树bincount固定为2，只有链表的话binCount大于等于树化阈值
                    if (binCount >= TREEIFY_THRESHOLD)
                    	//调用链表转为红黑树的方法，不过这里只看到了红黑树结构中双链表的转换没有看到树的转换
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //1.统计当前table一共有多少数据,2.判断是否达到扩容阈值标准，触发扩容 
        addCount(1L, binCount);
        //如果插入的k-v之前已经存在，那么返回的是oldVal，如果插入的k-v之前不存在，那么返回的是null
        return null;
    }

(3)initTable方法

ConcurrentHashMap()，ConcurrentHashMap(int initialCapacity)，ConcurrentHashMap(int initialCapacity, float loadFactor)，ConcurrentHashMap(int initialCapacity,float loadFactor, int concurrencyLevel)会使用initTable()初始化table数组，除了无参构造方法之外都会给sizeCtl初始化。防止多个线程同时初始化table数组，所以需要同步措施

    private final Node<K,V>[] initTable() {
    	//tab引用table数组
    	//sc表示临死局部的sizeCtl的值
        Node<K,V>[] tab; int sc;
        //如果
        while ((tab = table) == null || tab.length == 0) {
        	//sizeCtl<0表示已经有其他线程初始化(sizeCtl=-1)或者散列表正在扩容，当前线程会让出cpu进入下次循环
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                //使用双端检测机制+cas保证数组只会被初始化一次。防止其他线程已经初始化完毕了当前线程再次初始化，导致数据丢失
                    if ((tab = table) == null || tab.length == 0) {
                    	//创建散列表使用计算得到的初始化容量sizeCtl，使用sc保存sizeCtl，因为上面已经将sizeCtl置为-1
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                        table = tab = nt;
                        //sc=0.75n,表示下一次扩容时触发条件
                        sc = n - (n >>> 2);
                    }
                } finally {
                	//如果sizeCtl>0并且table初始化结束，那么sizeCtl表示扩容阈值
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

(4)addCount

    private final void addCount(long x, int check) {
    	//as表示LongAdder的cells
    	//b表示LongAdder的base
    	//s表示map.table中元素的数量
        CounterCell[] as; long b, s;
        //条件一表示cells已经初始化，true当前线程应该使用hash寻址找到何时的cell去累加数据false表示当前线程应该将数据累加到base中
        //条件二表示当前线程将数据累加到base中，flase表示竞争不激烈当前线程写base成功，数据累加到base中，true表示竞争激烈当前线程写base失败，当前线程应该尝试创建cells        
        if ((as = counterCells) != null ||
            !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            //进来的条件
            //1为true-->表示cells已经初始化了，当前线程应该寻址累加
            //2为true-->表示cells还没有初始化，但是当前线程累加到base中失败，尝试创建cells
            //a表示当前线程hash寻址命中的cell，v表示当前线程写cell的期望值，m表示当前cells的长度
            CounterCell a; long v; int m;
            //true表示未发生竞争，false表示发生竞争
            boolean uncontended = true;
            //条件一：as == null || (m = as.length - 1) < 0为true表示cells没有初始化，通过写base竞争失败进入
            //条件二:a = as[ThreadLocalRandom.getProbe() & m]) == null为true表示当前线程已经初始化，但是当前线程命中的cell为空，需要当前线程进入fullAddCount初始化cell放入命中位置
            //条件三：!(uncontended =U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))表示当前命中的cell不为空为true表示当前线程累加v失败，需要当前线程进入fullAddCount重新rehash或者扩容知道将v加到累加器中
            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);
                //考虑到fullAddCount比较耗时，那么当前线程不参与扩容逻辑了，直接返回到调用点
                return;
            }
            //check就是之前的binCount有三种情况：1、>=1 表示桶位中链表的长度或者插入的值和桶中本来的值相等2、=0 插入数据时，桶位中还没数据3、=2 表示桶位已经树化了
            //remove操作时，check可能=-1
            if (check <= 1)
                return;
            //通过累加cells中的所有值和baseCount的值，获取当前散列表中所有元素的个数 
            s = sumCount();
        }
        //表示一定是put操作调用的addCount
        if (check >= 0) {
        	//tab 表示map.table
        	//nt表示map.nextTable,表示扩容的新table
        	//n表示map.table数组的长度
        	//sc表示siezeCtl的临时值
            Node<K,V>[] tab, nt; int n, sc;
            //自旋
            /**
            sizeCtl的可能情况为:
            1.sizeCtl<0 当前table正在扩容，高16为表示扩容的标识戳，低16位标识(1+nThread)当前参与并发扩容的线程数量
            2.sizeCtl>0 如果table已经初始化，表示下次扩容时触发的条件
            */
            //条件一: s >= (long)(sc = sizeCtl)
            //true ->
            //      1.当前sizeCtl为负数，表示正在扩容中
            //      2.当前sizeCtl为正数，表示扩容阈值  
            //因为s表示table的size，当s>=sizeCtl一种情况是正在扩容中，另一种情况是触发了第一次扩容
            //条件二:恒成立
            //条件三:(n = tab.length) < MAXIMUM_CAPACITY) 
            //true ->当前table长度小于最大值限制则可以扩容              
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
                   (n = tab.length) < MAXIMUM_CAPACITY) {
                //Integer.numberOfLeadingZeros(n) | (1 << (RESIZE_STAMP_BITS - 1));只要从16->32进行扩容那么得到的标识戳是一致的
                int rs = resizeStamp(n);
                //表示当前table正在扩容
                //当前线程应协助table完成扩容
                if (sc < 0) {
                	//条件一:sc >>> RESIZE_STAMP_SHIFT) != rs
                	//true说明当前线程获取到的扩容唯一标识戳非本批次扩容
                	//false说明当前线程获取到的扩容唯一标识戳是本批次扩容
                	//条件二：jdk1.8中的bug，其实想要表达是sc==(rs<<16)+1
                	//true表示扩容完毕，当前线程不需要再次参与进来
                	//false表示扩容正在进行中，当前线程可以参与进来
					/**
					sc本来就是rs<<16+线程数+1。
					*/
                	//条件三:jdk1.8中有bug，其实想要表达sc==(rs<<16)+MAX_RESIZES
                	//true表示当前参与并发扩容的线程已经达到了最大值65535-1
                	//false表示当前线程可以参与进来
                	//条件四:nt==nextTable==null
                	//true表示本次扩容结束
                	//false表示扩容正在进行中
                    if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                        sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                        transferIndex <= 0)
                        break;
                    //前置条件:当前table正在执行扩容中，当前线程有机会参加扩容。U.compareAndSwapInt(this, SIZECTL, sc, sc + 1)为
                    //true表示当前线程成功参与到扩容任务中，并且当前参与扩容的线程+1
                    //false表示参与工作的线程比较多，cas修改失败了下次自旋大概率还会来这里
                    //1.当前很多线程都在此处尝试修改sizeCtl，有其他一个线程修改成功了，导致你的sc期望值和内存中不一致导致修改事变
                    //2.transfer任务内部的线程也修改了sizeCtl
                    if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    	//协助扩容线程，持有nextTable参数
                        transfer(tab, nt);
                }
                //RESIZE_STAMP_SHIFT为16
                //表示触发了第一次扩容，会将sizeCtl改成rs向左移动16位之后加2(共计32位),+2表示已(1+thread1)
                else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                             (rs << RESIZE_STAMP_SHIFT) + 2))
                    //触发扩容条件的线程不持有nextTable参数                         
                    transfer(tab, null);
                //如果还没扩容完，那么线程还会自旋，如果扩容完毕之后那么s
                s = sumCount();
            }
        }
    }

(5)transfer方法

    private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    	//n表示扩容之前table数组的长度
    	//stride表示分配给线程任务的步长
        int n = tab.length, stride;
        if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
            stride = MIN_TRANSFER_STRIDE; // subdivide range
         //条件成立：表示当前线程为触发本次扩容的线程，需要做扩容准备工作
         //条件不成立:表示当前线程是协助扩容的线程
        if (nextTab == null) {            // initiating
            try {
                @SuppressWarnings("unchecked")
                //创建了一个比可扩容之前大一倍的table
                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被volatile修饰，赋值给对象属性nextTable方便协助扩容线程拿到新表
            nextTable = nextTab;
            //记录迁移数据整体位置的标记，从n开始到1结束
            transferIndex = n;
        }
        //表示新数组的长度
        int nextn = nextTab.length;
        //fwd节点，当某个桶位数据处理完毕后，将此桶位设置为fwd节点，其他写线程，或读线程看到会有不同的逻辑
        ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
        //表示推进标记
        boolean advance = true;
        //表示循环标记
        boolean finishing = false; // to ensure sweep before committing nextTab
        //i表示分配给当前线程任务执行到的桶位
        //bound表示分配给当前线程任务的下界限制。16迁移到32中，是从16开始迁移到1结束
        for (int i = 0, bound = 0;;) {
        //f表示桶位中的头结点，fh表示头结点的hash
            Node<K,V> f; int fh;
            /**
            	1.给当前线程分配任务区间
            	2.维护当前线程任务进度(i表示当前处理的桶位)
            	3.维护map对象全局范围的进度
            */
            while (advance) {
            	//分配任务的开始下标
            	//分配任务的结束下标
                int nextIndex, nextBound;
                //case1：
                //成立：当前线程任务还没完成，还有相应区间的桶位要处理，--i 就让当前线程处理下一个桶位	
                //不成立:表示当前线程任务已完成或者未分配
                if (--i >= bound || finishing)
                    advance = false;
                //case2：
                //前置条件:当前线程任务已完成或者当前线程任务未分配
                //transferIndex表示全局范围内任务处理到哪里
                //条件成立:表示对象全局范围内的桶位都已经分配完了，没有区间可以分配了，设置当前线程的i变量为-1，跳出循环后，执行退出迁移任务相关的程序
                //条件不成立：表示对象全局范围内的桶位尚未分配，还有区间可以进行分配
                else if ((nextIndex = transferIndex) <= 0) {
                    i = -1;
                    advance = false;
                }
                //case3
                //前置条件：1当前线程需要分配任务区间，2全局范围内还有桶位尚未完成迁移
                //条件成立：说明给当前线程分配任务成功
                //条件失败：说明分配给当前线程失败，该线程会进入while自旋
                else if (U.compareAndSetInt
                         (this, TRANSFERINDEX, nextIndex,
                          nextBound = (nextIndex > stride ?
                                       nextIndex - stride : 0))) {
                                       
                    bound = nextBound;
                    //因为transferIndex比数组下标大1，所以此处需要-1
                    i = nextIndex - 1;
                    //advance=false这样下次线程可以跳出while循环
                    advance = false;
                }
            }
            /**
            	处理线程任务完成后，线程退出transfer方法的逻辑
            	//i >= n || i + n >= nextn一定成立
            	//如果i<0为true表示当前线程未分配到任务
            */
            //case1:
            if (i < 0 || i >= n || i + n >= nextn) {
            	//保存sizeCtl的变量
                int sc;
                if (finishing) {
                    nextTable = null;
                    table = nextTab;
                    sizeCtl = (n << 1) - (n >>> 1);
                    return;
                }
                //如果当前线程没分配到任务，那么线程应该退出transfer方法，sc高16位标识扩容戳，低16位标识扩容的线程总数+1，当前线程退出扩容时需要将线程总数-1
                if (U.compareAndSetInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {
                	//resizeStamp(n) << RESIZE_STAMP_SHIFT表示16位扩容到32位的戳
                	//sc-2!=resizeStamp(n) << RESIZE_STAMP_SHIFT表示当前线程不是最后一个退出扩容的线程，直接退出
                    if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                        return;
                     //if条件不成立
                    finishing = advance = true;
                    i = n; // recheck before commit
                }
            }
            /**
            	下面的代码:线程处理一个桶位数据的迁移工作，处理完毕之后设置advance为true 表示继续推进然后就会回到for循环 case2-case4的前置条件，当前线程任务尚未处理完，正在进行中
            */
            //case2:
            //条件成立：说明当前桶位尚未存放数据，只需要将此处设置为fwd节点即可
            //条件不成立：说明当前桶位也有其他线程向里面存放数据，那么cas会失败此时可能会走到case4连的逻辑。
            else if ((f   = tabAt(tab, i)) == null)
                advance = casTabAt(tab, i, null, fwd);
            //case3：
            //条件成立：说明当前桶位已经迁移过了，当前线程不需要再处理。直接再次更新当前线程任务索引，再次处理下一个桶位或其他操作
            else if ((fh = f.hash) == MOVED)
                advance = true; // already processed
            //case4:   
            //当前桶位有数据，而且有node节点不是fwd节点，当前节点所在需要迁移 
            else {
            	//锁住头结点
                synchronized (f) {
               		 //二次检查，防止头结点已经被修改，导致目前加锁对象错误
                    if (tabAt(tab, i) == f) {
                    	//ln表示低位链表引用，hn表示高位链表的引用
                        Node<K,V> ln, hn;
                        //条件成立表示当前桶位是链表桶位
                        if (fh >= 0) {
                        	//lastRun
                        	//可以获取当前链表末尾连续高位不变的node
                            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;
                                }
                            }
                            //条件成立：说明lastRun引用链表为低位链表，那么就让ln指向低位链表
                            if (runBit == 0) {
                                ln = lastRun;
                                hn = null;
                            }
                            //否则，说明lastRun引用的链表为高位链表，就让hn指向高位链表
                            else {
                                hn = lastRun;
                                ln = null;
                            }
                            //迭代链表，跳出条件：当前循环节点不等于lastRun引用跳出循环
                            for (Node<K,V> p = f; p != lastRun; p = p.next) {
                                int ph = p.hash; K pk = p.key; V pv = p.val;
                                if ((ph & n) == 0)
                                	//【头插法】，此次新建的节点的next指向上一个节点，然更新ln的引用，因为在遍历整个链表，如果使用尾插法会造成链表断裂
                                    ln = new Node<K,V>(ph, pk, pv, ln);
                                else
                                    hn = new Node<K,V>(ph, pk, pv, hn);
                            }
                            // 高低位链设置到新表中的指定位置
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            // 老表中的该桶位设置为 fwd 节点
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                        //条件成立，表示当前桶位是红黑树代理节点
                        else if (f instanceof TreeBin) {
                        	//转换头结点为treebin节点
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            //低位链表的头结点，loTail 低位链表的尾节点
                            TreeNode<K,V> lo = null, loTail = null;
                            TreeNode<K,V> hi = null, hiTail = null;
                            //lc表示低位链表元素数量
                            int lc = 0, hc = 0;
                            //迭代treebin中的双向链表，从头结点迭代到尾节点
                            for (Node<K,V> e = t.first; e != null; e = e.next) {
                            	//h表示当前的hash
                                int h = e.hash;
                                //使用当前节点构建出来的新的TreeNode
                                TreeNode<K,V> p = new TreeNode<K,V>
                                    (h, e.key, e.val, null, null);
                               //条件成立：表示当前循环节点属于低位链节点     
                                if ((h & n) == 0) {
                                	//尾插法
                                	//条件成立：说明当前低位链表还没有数据
                                    if ((p.prev = loTail) == null)
                                        lo = p;
                                    //说明低位链表已经有数据，此时链表元素追加到低位链表的末尾
                                    else
                                        loTail.next = p;
                                    loTail = p;
                                    ++lc;
                                }
                                //高位链表和低位链表逻辑相同
                                else {
                                    if ((p.prev = hiTail) == null)
                                        hi = p;
                                    else
                                        hiTail.next = p;
                                    hiTail = p;
                                    ++hc;
                                }
                            }
                            //如果低位/高位链表的长度小于6那么将树转为链表，拆出来是两个链表，那么只能老老实实的构建红黑树，否则可以引用之前的红黑树节点
                            ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                                (hc != 0) ? new TreeBin<K,V>(lo) : t;
                            hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                                (lc != 0) ? new TreeBin<K,V>(hi) : t;                                
                            setTabAt(nextTab, i, ln);
                            setTabAt(nextTab, i + n, hn);
                            setTabAt(tab, i, fwd);
                            advance = true;
                        }
                    }
                }
            }
        }
    }

链表迁移过程

(6) helpTransfer方法

//其他线程帮助扩容会传过来两个参数：扩容之前的数组和当前节点为fwd节点
final Node<K,V>[] helpTransfer(Node<K,V>[] tab, Node<K,V> f) {
		//nextTaby引用的是fwd.nextTable ==map.nextTable理论上是这样
		//sc保存map.sizeCtl
        Node<K,V>[] nextTab; int sc;
        //条件一：tab != null恒成立
        //条件二：f instanceof ForwardingNode恒成立
        //条件三：((ForwardingNode)f).nextTable) != null恒成立
        if (tab != null && (f instanceof ForwardingNode) &&
            (nextTab = ((ForwardingNode<K,V>)f).nextTable) != null) {
            //用当前表长度获取扩容标识戳，假设16-->32
            int rs = resizeStamp(tab.length);
            //条件一：nextTab == nextTable
            //成立：表示当前正在扩容中
            //不成立：1.nextTable 被设置为null，扩容完毕之后会被设置为null
            //		 2.再次触发扩容了...nextTab已经过期了
            //条件二：table == tab
            //成立：扩容正在进行中还未完成
            //不成立：扩容已经结束，扩容结束之后，最后退出的线程会设置nextTable为table
            //条件三：sc = sizeCtl
            //成立：扩容正在进行中
            //不成立：说明sizeCtl是一个大于0的数，此时代表下次扩容的阈值，表示扩容已经结束
            while (nextTab == nextTable && table == tab &&
                   (sc = sizeCtl) < 0) {
                //条件一:sc >>> RESIZE_STAMP_SHIFT) != rs
                	//true说明当前线程获取到的扩容唯一标识戳非本批次扩容
                	//false说明当前线程获取到的扩容唯一标识戳是本批次扩容
                	//条件二：jdk1.8中的bug，其实想要表达是sc==(rs<<16)+1
                	//true表示扩容完毕，当前线程不需要再次参与进来
                	//false表示扩容正在进行中，当前线程可以参与进来
					/**
					sc本来就是rs<<16+线程数+1。
					*/
                	//条件三:jdk1.8中有bug，其实想要表达sc==(rs<<16)+MAX_RESIZES
                	//true表示当前参与并发扩容的线程已经达到了最大值65535-1
                	//false表示当前线程可以参与进来
                	//条件四:transferIndex <= 0
                	//true 表示map对象全局范围内的任务已经分配完
                	//false 表示还有任务可以分配
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || transferIndex <= 0)
                    break;
                if (U.compareAndSetInt(this, SIZECTL, sc, sc + 1)) {
                    transfer(tab, nextTab);
                    break;
                }
            }
            //当前线程扩容完毕，将扩容之后的数组返回
            return nextTab;
        }
        return table;
    }

(7)get按方法

    public V get(Object key) {
    	//tab引用map.table
       // e 表示当前元素
       //p表示目标节点
       //n 表示table长度
       //eh 表示当前元素hash
       //ek 当前元素key
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        //写数据时就是根据扰动运算得到的hash
        int h = spread(key.hashCode());
        //条件一：tab=table！=null
        //true:表示已经put过数据，并且map内部的table已经初始化完毕
        //false:new Hashmap之后没有put过数据。map的table是延迟初始化的，只有第一次写数据会触发创建逻辑
        //条件二：(n = tab.length) > 0
        //条件三： e = tabAt(tab, (n - 1) & h)) != null
        //true：当前key寻址的同为有值
        //false：表示当前key寻址的同为是null，是null直接返回null
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            //当前桶位的hash只能说明后几位一致，不能说明完全一致
            //条件成立：说明头结点和查询key的hash完全一致
            if ((eh = e.hash) == h) {
            	//因为hash会冲突所以还需要完全比对查询key和查询key
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            //条件成立
            //1.-1 fwd说明table正在扩容，且当前查询的这个桶位的数据已经被迁移走了
            //2.-2 TreeBin结点，需要使用TreeBin提供的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;
    }

(8) fwd_find方法

Node<K,V> find(int h, Object k) {
            // loop to avoid arbitrarily deep recursion on forwarding nodes
            //Node[] tab = nextTable ,tab一定不为空
            outer: for (Node<K,V>[] tab = nextTable;;) {
            	//n 表示为扩容创建的新表的长度
            	//e 表示为扩容而创建的新表使用寻址算法得到的桶位头结点
                Node<K,V> e; int n;
                //条件一k == null永远不成立
                //条件二tab == null永远不成立
                //条件三 (n = tab.length) == 0永远不成立
                //条件四e = tabAt(tab, (n - 1) & h)) == null在新扩容表中重新hash定位头结点
                //true：
                //1.在oldtable中，对应的桶位在迁移之前就是null
                //2.扩容完成之后，有其他线程将此桶位设置为null
                if (k == null || tab == null || (n = tab.length) == 0 ||
                    (e = tabAt(tab, (n - 1) & h)) == null)
                    return null;
                //前置条件：扩容后的表对应的hash的桶位一定不是null，e为此桶位的头结点
                //e可能为哪些node类型?
                //1.node类型
                //2.TreeBin类型
                //3.fwd类型
                //4.单个节点
                for (;;) {
                	//eh新扩容后指定桶位的当前节点的hash
                	//ek新扩容后指定桶位的当前节点的key
                    int eh; K ek;
                    //条件成立：说明新扩容之后的表，当前命中桶位的数据即为查询想要的数据
                    if ((eh = e.hash) == h &&
                        ((ek = e.key) == k || (ek != null && k.equals(ek))))
                        return e;
                     //eh<0
                     //1.TreeBin类型 2.FWD类型：新扩容的表在并发很大的情况下，再次扩容
                    if (eh < 0) {
                    	//如果是FWD节点，计算出下一次扩容的table，然后再重新定位
                        if (e instanceof ForwardingNode) {
                            tab = ((ForwardingNode<K,V>)e).nextTable;
                            continue outer;
                        }
                        else
                        	//说明此桶位为trrBin节点，使用treeBin的find查找红黑树节点
                            return e.find(h, k);
                    }
                    //当前桶位的节点为链表节点，遍历链表（跳到内层循环）
                    if ((e = e.next) == null)
                        return null;
                }
            }
        }

一些ConcurrentHashMap的面试知识点
并发map存储数据结构是什么样子的?

和普通的HashMap一样都是数组+链表+红黑树，存储的结构是node，node节点由节点hash值，key，value和next组成，next解决hash冲突生成链表。

并发map的负载因子可以修改吗？

普通的HashMap的负载因子可以修改，并发 Map的负载因子使用final进行修饰不能被修改

Node的hash字段一般情况下必须>=0，为什么?

扩容的时候，FWDNode的hash值是-1，TreeNode的hash值是-2