ConcurrentHashMap源码分析(2)—

ConcurrentHashMap源码分析(1)——JDK1.7的实现

前言

在JDK1.7版本上，ConcurrentHashMap还是通过分段锁来实现的，Segment的数量制约着并发量。在JDK1.8中，已经摒弃了这种结构设计，而是直接采用Node数组+链表+红黑树的结构来实现，同时并发控制使用Synchronized和CAS来操作。

先看基本属性

// node数组最大容量：2^30=1073741824
private static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认初始值，必须是2的幕数
private static final int DEFAULT_CAPACITY = 16;
//数组可能最大值，需要与toArray（）相关方法关联
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//并发级别，遗留下来的，为兼容以前的版本
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 负载因子
private static final float LOAD_FACTOR = 0.75f;
// 链表转红黑树阀值,> 8 链表转换为红黑树
static final int TREEIFY_THRESHOLD = 8;
//树转链表阀值，小于等于6（tranfer时，lc、hc=0两个计数器分别++记录原bin、新binTreeNode数量，<=UNTREEIFY_THRESHOLD 则untreeify(lo)）
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
private static final int MIN_TRANSFER_STRIDE = 16;
private static int RESIZE_STAMP_BITS = 16;
// 2^15-1，help resize的最大线程数
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;
// 32-16=16，sizeCtl中记录size大小的偏移量
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// forwarding nodes的hash值
static final int MOVED     = -1;
// 树根节点的hash值
static final int TREEBIN   = -2;
// ReservationNode的hash值
static final int RESERVED  = -3;
// 可用处理器数量
static final int NCPU = Runtime.getRuntime().availableProcessors();
//存放node的数组
transient volatile Node<K,V>[] table;
/*控制标识符，用来控制table的初始化和扩容的操作，不同的值有不同的含义*当为负数时：-1代表正在初始化，-N代表有N-1个线程正在 进行扩容*当为0时：代表当时的table还没有被初始化*当为正数时：表示初始化或者下一次进行扩容的大小*/
private transient volatile int sizeCtl;

这些基本属性，声明了JDK1.8版本的ConcurrentHashMap的初始容量、加载因子、扩容等一些边界和必要的操作。

再看数据结构

其实相比于JDK1.7版本的ConcurrentHashMap，JDK1.8版本的数据结构要简单一些，使用的是和HashMap相同的结构：数组+链表+红黑树。说白了吧，ConcurrentHashMap中包含的就是一个Node类型的table数组。

Node

可以说Node是ConcurrentHashMap在存储结构上的基本单元，是继承自Map.Entry<K, V>的链表。当链表中的数据>8的时候，就会把该结构升级为TreeBin类型的红黑树结构。顺便提一下扩容，刚才看基本属性的时候也看到了，控制标识符sizeCtl：0代表hash表尚未初始化；正数表示已初始化或下一次扩容的大小，即阈值；-1表示正在进行初始化；-N表示当前有N-1个线程正在扩容操作。
源码如下：

static class Node<K,V> implements Map.Entry<K,V> {//链表的数据结构final int hash;final K key;//val和next都会在扩容时发生变化，所以加上volatile来保持可见性和禁止重排序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; }//不允许更新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;}
}

我们把焦点移动到setValue(V value)上，不允许更新value，只能对数据查找，不能修改。这是重点，画起来，以后考！

TreeNode

前面我们提到过，当链表中的节点数>8时，就会升级为TreeBin类型的红黑树。该过程就是通过TreeNode作为新的存储结构代替Node转换成红黑树。下面是TreeNode的源码：

static final class TreeNode<K,V> extends Node<K,V> {//树形结构的属性定义TreeNode<K,V> parent;  // red-black tree linksTreeNode<K,V> left;TreeNode<K,V> right;TreeNode<K,V> prev;    // needed to unlink next upon deletionboolean 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);}//根据key查找 从根节点开始找出相应的TreeNode，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;elsep = pl;} while (p != null);}return null;}
}

TreeBin

TreeBin作为封装了TreeNode的容器，内部提供了红黑树转换的条件和锁的控制。

static final class TreeBin<K,V> extends Node<K,V> {//指向TreeNode列表和根节点TreeNode<K,V> root;volatile TreeNode<K,V> first;volatile Thread waiter;volatile int lockState;// 读写锁状态static final int WRITER = 1; // 获取写锁的状态static final int WAITER = 2; // 等待写锁的状态static final int READER = 4; // 增加数据时读锁的状态/*** 初始化红黑树*/TreeBin(TreeNode<K,V> b) {super(TREEBIN, null, null, null);this.first = b;TreeNode<K,V> r = null;for (TreeNode<K,V> x = b, next; x != null; x = next) {next = (TreeNode<K,V>)x.next;x.left = x.right = null;if (r == null) {x.parent = null;x.red = false;r = x;}else {K k = x.key;int h = x.hash;Class<?> kc = null;for (TreeNode<K,V> p = r;;) {int dir, ph;K pk = p.key;if ((ph = p.hash) > h)dir = -1;else if (ph < h)dir = 1;else if ((kc == null &&(kc = comparableClassFor(k)) == null) ||(dir = compareComparables(kc, k, pk)) == 0)dir = tieBreakOrder(k, pk);TreeNode<K,V> xp = p;if ((p = (dir <= 0) ? p.left : p.right) == null) {x.parent = xp;if (dir <= 0)xp.left = x;elsexp.right = x;r = balanceInsertion(r, x);break;}}}}this.root = r;assert checkInvariants(root);}......
}

链表、红黑树怎么转换？

table元素会根据包含其中的Node节点数，在链表和红黑树两种结构中转换。

链表——>>红黑树

往table中添加元素，如果该元素所处的链表节点个数>8,就会触发链表向红黑树结构转换。具体要通过treeifyBin方法来实现：

    private final void treeifyBin(Node<K,V>[] tab, int index) {Node<K,V> b; int n, sc;if (tab != null) {//检查hash表大小与MIN_TREEIFY_CAPACITY关系if ((n = tab.length) < MIN_TREEIFY_CAPACITY)tryPresize(n << 1);else if ((b = tabAt(tab, index)) != null && b.hash >= 0) {synchronized (b) {if (tabAt(tab, index) == b) {TreeNode<K,V> hd = null, tl = null;for (Node<K,V> e = b; e != null; e = e.next) {TreeNode<K,V> p =new TreeNode<K,V>(e.hash, e.key, e.val,null, null);if ((p.prev = tl) == null)hd = p;elsetl.next = p;tl = p;}setTabAt(tab, index, new TreeBin<K,V>(hd));}}}}}

首先要检查hash表大小和MIN_TREEIFY_CAPACITY的关系，默认值64。如果小于此值，表示直接扩容即可，无需向红黑树方向转换。如果>64,就是用CAS获取指定的Node节点，然后对其synchronized加锁，但并不影响其他节点操作，故在并发方面效率很高。加锁之后，便将Node所在链表，转换为了红黑树。

红黑树——>>链表

有增就有删，有加就有减。在table中删除元素时，若该元素所在红黑树的节点数<6，就会使红黑树转通过untreeify变成链表：

    static <K,V> Node<K,V> untreeify(Node<K,V> b) {Node<K,V> hd = null, tl = null;for (Node<K,V> q = b; q != null; q = q.next) {Node<K,V> p = new Node<K,V>(q.hash, q.key, q.val, null);if (tl == null)hd = p;elsetl.next = p;tl = p;}return hd;}

啥是CAS？

大家还记得不，上面我们提到了CAS。研究CAS之前，首先我们得先了解一个概念。一般来讲，锁分为悲观锁和乐观锁。其中，悲观锁（实现是各种锁）是比较“极端”的。对同一个数据的并发操作，悲观锁认为一定会发生修改；相对于悲观锁，乐观锁（由CAS比较交换实现）还相对“柔和”一些。乐观锁认为对同一个数据的并发操作，并不会对数据产生修改影响，在更新数据时会采用尝试更新不断重试的方式更新数据。
Compare And Swap有3个操作数：内存值V、预期值A、要修改的新值B。if(V==A){V=B}。Java中CAS操作通过JNI本地方法实现，在JVM中程序会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀；反之，如果程序是在单处理器上运行，就省略lock前缀。

lock前缀？

1、确保对内存的读-改-写操作原子执行。之前采用锁定总线的方式，但开销很大；后来改用缓存锁定来保证指令执行的原子性。
2、禁止该指令与之前和之后的读和写指令重排序。
3、把写缓冲区中的所有数据刷新到内存中。

CAS同时具有volatile读和volatile写的内存语义。不过CAS操作也存在一些缺点：1. 存在ABA问题，其解决思路是使用版本号；2. 循环时间长，开销大；3. 只能保证一个共享变量的原子操作。

构造方法

一般我们通过new ConcurrentHashMap()来进行初始化，但是这个版本有点特殊，在空构造中什么都没做。

public ConcurrentHashMap() {}
public ConcurrentHashMap(int initialCapacity) {if (initialCapacity < 0)throw new IllegalArgumentException();int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?MAXIMUM_CAPACITY :tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));this.sizeCtl = cap;
}

但是如果传入初始容量、加载因子和并发度这几个参数的时候，就会去计算table数组的初始大小sizeCtl的值。初始化操作并不是在构造函数中实现的，而是在put操作中实现的。

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();// 得到 hash 值，通过两次hash方法来减少hash冲突，使之均匀分布int hash = spread(key.hashCode());// 用于记录相应链表的长度int binCount = 0;for (Node<K,V>[] tab = table;;) {//对table迭代Node<K,V> f; int n, i, fh;// 如果数组"空"，进行数组初始化。这也就是上面构造方法中没有进行的初始化，运用的是懒汉式初始化if (tab == null || (n = tab.length) == 0)// 初始化数组，对table进行初始化操作tab = initTable();// 找该 hash 值对应的数组下标，得到第一个节点 felse if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {// 如果数组该位置为空，//    用一次 CAS 操作将这个新值放入其中即可，这个 put 操作差不多就结束了，可以拉到最后面了//          如果 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);else { // 到这里就是说，f 是该位置的头结点，而且不为空V oldVal = null;// 如果以上条件都不满足，那就要进行加锁操作，也就是存在hash冲突，锁住链表或者红黑树的头结点synchronized (f) {if (tabAt(tab, i) == f) {if (fh >= 0) { // 头结点的 hash 值大于 0，说明是链表// 用于累加，记录链表的长度binCount = 1;// 遍历链表for (Node<K,V> e = f;; ++binCount) {K ek;// 如果发现了"相等"的 key，判断是否要进行值覆盖，然后也就可以 break 了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;}}}}// binCount != 0 说明上面在做链表操作if (binCount != 0) {// 判断是否要将链表转换为红黑树，临界值和 HashMap 一样，也是 8if (binCount >= TREEIFY_THRESHOLD)// 这个方法和 HashMap 中稍微有一点点不同，那就是它不是一定会进行红黑树转换，// 如果当前数组的长度小于 64，那么会选择进行数组扩容，而不是转换为红黑树// 这个方法上面已经说过了treeifyBin(tab, i);if (oldVal != null)return oldVal;break;}}}// addCount(1L, binCount);return null;
}

这里我们总结一下对table进行无条件自循环直至put成功，大致分为以下6个步骤：
1.如果没有初始化就先调用initTable（）来初始化
2.若没有hash冲突就直接CAS插入
3.若正在扩容则先进行扩容
4.若存在hash冲突，则通过加锁来保证线程安全：链表就直接遍历到尾端插入：红黑树就旋转插入
5.如果该链表的数量大于阈值8，就要先转换成黑红树的结构，break再一次进入循环
6.如果添加成功就调用addCount（）方法统计size，并且检查是否需要扩容
简单来讲，整个put主流程，解决了3个问题：初始化——>扩容——>数据迁移。
接下来我们来逐个分析。

初始化initTable

初始化一个合适大小的数组，然后设置sizeCtl。

private final Node<K,V>[] initTable() {Node<K,V>[] tab; int sc;//空table才能进行初始化操作while ((tab = table) == null || tab.length == 0) {// 初始化的工作被其他线程抢走了，挂起当前线程if ((sc = sizeCtl) < 0)Thread.yield(); // lost initialization race; just spin// CAS 一下，将 sizeCtl 设置为 -1，表示初始化状态，代表抢到了锁else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {try {if ((tab = table) == null || tab.length == 0) {// DEFAULT_CAPACITY 默认初始容量是 16int n = (sc > 0) ? sc : DEFAULT_CAPACITY;// 初始化数组，长度为 16 或初始化时提供的长度Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];// 将这个数组赋值给 table，table 是 volatile 的table = tab = nt;// 记录下次扩容的大小，如果 n 为 16 的话，那么这里 sc = 12，其实就是 0.75 * nsc = n - (n >>> 2);}} finally {// 设置 sizeCtl 为 sc，我们就当是 12 吧sizeCtl = sc;}break;}}return tab;
}

扩容tryPresize

这里的扩容也是做翻倍扩容的，扩容后数组容量为原来的 2 倍。

// 首先要说明的是，方法参数 size 传进来的时候就已经翻了倍了
private final void tryPresize(int size) {// c：size 的 1.5 倍，再加 1，再往上取最近的 2 的 n 次方。int c = (size >= (MAXIMUM_CAPACITY >>> 1)) ? MAXIMUM_CAPACITY :tableSizeFor(size + (size >>> 1) + 1);int sc;while ((sc = sizeCtl) >= 0) {Node<K,V>[] tab = table; int n;// 这个 if 分支和之前说的初始化数组的代码基本上是一样的，在这里，我们可以不用管这块代码if (tab == null || (n = tab.length) == 0) {n = (sc > c) ? sc : c;if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {try {if (table == tab) {@SuppressWarnings("unchecked")Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];table = nt;sc = n - (n >>> 2); // 0.75 * n}} finally {sizeCtl = sc;}}}else if (c <= sc || n >= MAXIMUM_CAPACITY)break;else if (tab == table) {int rs = resizeStamp(n);if (sc < 0) {Node<K,V>[] nt;if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||transferIndex <= 0)break;// 2. 用 CAS 将 sizeCtl 加 1，然后执行 transfer 方法//    此时 nextTab 不为 nullif (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))transfer(tab, nt);}// 1. 将 sizeCtl 设置为 (rs << RESIZE_STAMP_SHIFT) + 2)//  调用 transfer 方法，此时 nextTab 参数为 nullelse if (U.compareAndSwapInt(this, SIZECTL, sc,(rs << RESIZE_STAMP_SHIFT) + 2))transfer(tab, null);}}
}

核心在于对sizeCtl的操作，首先将其设置为一个负数，然后执行 transfer(tab, null)，再下一个循环将 sizeCtl 加 1，并执行 transfer(tab, nt)，之后可能是继续 sizeCtl 加 1，并执行 transfer(tab, nt)。

数据迁移transfer

主要就是为了将原来的 tab 数组的元素迁移到新的 nextTab 数组中。我们在上面扩容操作tryPresize方法中多次调用该方法并不涉及多线程，但是transfer依旧可以在其他地方被调用，比如put操作中调用了 helpTransfer 方法，helpTransfer 方法会调用 transfer 方法的。
很明显，该方法支持多线程执行，外围调用此方法的时候，会保证第一个发起数据迁移的线程，nextTab 参数为 null，之后再调用此方法的时候，nextTab 不会为 null。

private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {int n = tab.length, stride;// stride 在单核下直接等于 n，多核模式下为 (n>>>3)/NCPU，最小值是 16，小于16就强制16// stride 可以理解为”步长“，有 n 个位置是需要进行迁移的，//   将这 n 个任务分为多个任务包，每个任务包有 stride 个任务if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)stride = MIN_TRANSFER_STRIDE; // subdivide range// 如果 nextTab 为 null，先进行一次初始化//    前面我们说了，外围会保证第一个发起迁移的线程调用此方法时，参数 nextTab 为 null//       之后参与迁移的线程调用此方法时，nextTab 不会为 nullif (nextTab == null) {try {// 容量翻倍Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];nextTab = nt;} catch (Throwable ex) {      // try to cope with OOMEsizeCtl = Integer.MAX_VALUE;return;}// nextTable 是 ConcurrentHashMap 中的属性nextTable = nextTab;// transferIndex 也是 ConcurrentHashMap 的属性，用于控制迁移的位置transferIndex = n;}int nextn = nextTab.length;// ForwardingNode 翻译过来就是正在被迁移的 Node// 这个构造方法会生成一个Node，key、value 和 next 都为 null，关键是 hash 为 MOVED// 后面我们会看到，原数组中位置 i 处的节点完成迁移工作后，就会将位置 i 处设置为这个 ForwardingNode，用来告诉其他线程该位置已经处理过了，所以它其实相当于是一个标志。（fwd的hash值为-1，fwd.nextTable=nextTab）ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);// advance =true指的是做完了一个位置的迁移工作，可以准备做下一个位置的了boolean advance = true;boolean finishing = false; // to ensure sweep before committing nextTab/** 下面这个 for 循环，最难理解的在前面，而要看懂它们，应该先看懂后面的，然后再倒回来看* */// i 是位置索引，bound 是边界，注意是从后往前for (int i = 0, bound = 0;;) {Node<K,V> f; int fh;// advance 为 true 表示可以进行下一个位置的迁移了//   控制 --i ,遍历原hash表中的节点。简单理解：i 指向了 transferIndex，bound 指向了 transferIndex-stridewhile (advance) {int nextIndex, nextBound;if (--i >= bound || finishing)advance = false;// 将 transferIndex 值赋给 nextIndex，这里 transferIndex 一旦小于等于 0，说明原数组的所有位置都有相应的线程去处理了else if ((nextIndex = transferIndex) <= 0) {i = -1;advance = false;}//用CAS计算得到的transferIndexelse if (U.compareAndSwapInt(this, TRANSFERINDEX, nextIndex,nextBound = (nextIndex > stride ?nextIndex - stride : 0))) {// 看括号中的代码，nextBound 是这次迁移任务的边界，注意，是从后往前bound = nextBound;i = nextIndex - 1;advance = false;}}if (i < 0 || i >= n || i + n >= nextn) {int sc;if (finishing) {// 所有的迁移操作已经完成nextTable = null;// 将新的 nextTab 赋值给 table 属性，完成迁移table = nextTab;// 重新计算 sizeCtl：n 是原数组长度，所以 sizeCtl 得出的值将是新数组长度的 0.75 倍sizeCtl = (n << 1) - (n >>> 1);return;//跳出死循环}// 之前我们说过，sizeCtl 在迁移前会设置为 (rs << RESIZE_STAMP_SHIFT) + 2// 然后，每有一个线程参与迁移就会将 sizeCtl 加 1，// 这里使用 CAS 操作对 sizeCtl 进行减 1，代表做完了属于自己的任务，新加入一个线程参与到扩容操作if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {// 任务结束，方法退出if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)return;// 到这里，说明 (sc - 2) == resizeStamp(n) << RESIZE_STAMP_SHIFT，// 也就是说，所有的迁移任务都做完了，也就会进入到上面的 if(finishing){} 分支了finishing = advance = true;i = n; // recheck before commit}}// f.hash == -1 表示遍历到了ForwardingNode节点，意味着该节点已经处理过了。这里是控制并发扩容的核心else if ((f = tabAt(tab, i)) == null)advance = casTabAt(tab, i, null, fwd);// 该位置处是一个 ForwardingNode，代表该位置已经迁移过了else if ((fh = f.hash) == MOVED)advance = true; // already processedelse {// 对数组该位置处的结点加锁，开始处理数组该位置处的迁移工作synchronized (f) {//节点复制工作if (tabAt(tab, i) == f) {Node<K,V> ln, hn;// 表示是链表节点if (fh >= 0) {// 构造两个链表  一个是原链表  另一个是原链表的反序排列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;}}if (runBit == 0) {ln = lastRun;hn = null;}else {hn = lastRun;ln = null;}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)ln = new Node<K,V>(ph, pk, pv, ln);elsehn = new Node<K,V>(ph, pk, pv, hn);}// 在nextTable i 位置处插上链表setTabAt(nextTab, i, ln);// 在nextTable i + n 位置处插上链表setTabAt(nextTab, i + n, hn);// 在table i 位置处插上ForwardingNode 表示该节点已经处理过了，其他线程一旦看到该位置的 hash 值为 MOVED，就不会进行迁移了setTabAt(tab, i, fwd);// advance 设置为 true，代表该位置已经迁移完毕，可以执行--i动作，遍历节点advance = true;}else if (f instanceof TreeBin) {// 红黑树的迁移TreeBin<K,V> t = (TreeBin<K,V>)f;TreeNode<K,V> lo = null, loTail = null;TreeNode<K,V> hi = null, hiTail = null;int lc = 0, hc = 0;for (Node<K,V> e = t.first; e != null; e = e.next) {int h = e.hash;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;elseloTail.next = p;loTail = p;++lc;}else {if ((p.prev = hiTail) == null)hi = p;elsehiTail.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;// 将 ln 放置在新数组的位置 isetTabAt(nextTab, i, ln);// 将 hn 放置在新数组的位置 i+nsetTabAt(nextTab, i + n, hn);// 将原数组该位置处设置为 fwd，代表该位置已经处理完毕，//    其他线程一旦看到该位置的 hash 值为 MOVED，就不会进行迁移了setTabAt(tab, i, fwd);// advance 设置为 true，代表该位置已经迁移完毕advance = true;}}}}}
}

这里对并发操作的机制做一个解释，原数组长度为n，意味着就有n个迁移任务。最简单的就是让每一个线程每次负责一个小任务。做完一个任务在检测是否有其他没做完的任务，然后就可以帮助迁移了。Doug Lea 使用了一个 stride，简单理解就是步长，每个线程每次负责迁移其中的一部分，比方说每次迁移 16 个小任务。所以，我们就需要一个全局的调度者来安排哪个线程执行哪几个任务，这个就是属性 transferIndex 的作用。
第一个发起数据迁移的线程会将 transferIndex 指向原数组最后的位置，然后从后往前的 stride 个任务属于第一个线程，然后将 transferIndex 指向新的位置，再往前的 stride 个任务属于第二个线程，依此类推。当然，这里说的第二个线程不是真的一定指代了第二个线程，也可以是同一个线程。其实就是将一个大的迁移任务分为了一个个任务包。
说到底，transfer 这个方法并没有实现所有的迁移任务，每次调用这个方法只实现了 transferIndex 往前 stride 个位置的迁移工作，其他的需要由外围来控制。

get操作

get操作从来都是最简单的，简单概括一下：
1.计算hash值，定位到该table索引位置，如果是首节点符合就返回
2.根据 hash 值找到数组对应位置: (n – 1) & h
3.根据该位置处结点性质进行相应查找：如果该位置为 null，那么直接返回 null 就可以了；如果该位置处的节点刚好就是我们需要的，返回该节点的值即可；如果该位置节点的 hash 值小于 0，说明正在扩容，或者是红黑树，后面我们再介绍 find 方法；如果以上 3 条都不满足，那就是链表，进行遍历比对即可；

public V get(Object key) {Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;int h = spread(key.hashCode());if ((tab = table) != null && (n = tab.length) > 0 &&(e = tabAt(tab, (n - 1) & h)) != null) {// 判断头结点是否就是我们需要的节点if ((eh = e.hash) == h) {if ((ek = e.key) == key || (ek != null && key.equals(ek)))return e.val;}// 如果头结点的 hash 小于 0，说明 正在扩容，或者该位置是红黑树else if (eh < 0)// 参考 ForwardingNode.find(int h, Object k) 和 TreeBin.find(int h, Object k)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;
}

如果遇到扩容的时候，会调用标志正在扩容节点ForwardingNode的find方法，查找该节点，匹配就返回。

size操作

public int size() {long n = sumCount();return ((n < 0L) ? 0 :(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :(int)n);
}
final long sumCount() {CounterCell[] as = counterCells; CounterCell a; //变化的数量long sum = baseCount;if (as != null) {for (int i = 0; i < as.length; ++i) {if ((a = as[i]) != null)sum += a.value;}}return sum;
}

针对size的计算，扩容和addCount方法中已经对其进行了处理，回顾1.7中是只有在调用size()方法时才去计算。

最后再总结一下

单从数据结构上来讲，JDK1.8的ConcurrentHashMap已经和HashMap基本上无异了。可能区别在于ConcurrentHashMap增加了同步操作来控制并发，从1.7的ReentrantLock+Segment+HashEntry，到JDK1.8synchronized+CAS+红黑树+HashEntry：
1.1.8对于锁的粒度上更为“精细”
2.结构更简单，抛弃了分段锁，使用synchronized来进行同步
3.使用红黑树优化链表结构，提高遍历效率
4.使用内置锁synchronized来代替重入锁ReentrantLock（可能是为了降低jvm内存开销、基于JVM的synchronized优化空间更大？）