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
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<sizeCtl就可能会跳出循环
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<K,V>)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<K,V>[] 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
451
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
