注：本博客资源来自于享学课堂，自己消化之后有修改
目录
使用
除了map有的线程安全的put和get方法外，ConcurrentHashMap还有在并发下的public V putIfAbsent(K key, V value)，如果key已经存在，直接返回value的值，不会进行替换。如果key不存在，就添加key和value，返回null，并且它是线程安全的。
在1.7下ConcurrentHashMap实现分析
在1.7下的实现原理图
备注：建议有想画这种图的同学，可以使用processon，非常好用
ConcurrentHashMap是有Segment数组结构和HashEntry数组组成，hashEntry每个元素是链表；Segment继承ReentrantLock，是一种可重入锁，ConcurrentHashMap上锁就是在Segment上。
HashEntry是一个数组，每个数组元素存放的是一个链表，每次对链表元素进行修改的时候，都必须获得数组对应的Segment锁
构造方法和初始化
public ConcurrentHashMap17(int initialCapacity,float loadFactor, int concurrencyLevel)
参数说明
| 参数 | 描述 | 默认值 |
| initialCapacity | ConcurrentHashMap初始容量，默认是 | DEFAULT_INITIAL_CAPACITY=16 |
| loadFactor | 负载因子阈值，用于控制大小调整。initailCapacity*loadFactor=HashMap的容量，负载越大，链表的数据越多，查找难度就会变大，负载越小，链表数据越少。 | DEFAULT_LOAD_FACTOR = 0.75f |
| concurrencyLevel |
估计并发级别，即可能会有多少个线程共同修噶爱这个map，以此来确定Segment数组大小，默认是16，必须是2的备注，如果设置17，正是就是32 |
DEFAULT_CONCURRENCY_LEVEL = 16 |
get操作
get操作先经过一次再散列的到A，然后通过|A高位获取到Senment[]的位置，然后通过A全部散列定位到在table[]中的位置。整个过程没有加锁，而是通过volatile保证get可以拿到最新值。
transient volatile HashEntry<K,V>[] table;
public V get(Object key) {
Segment<K,V> s;
HashEntry<K,V>[] tab;
//准备定位hash的值
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
//拿到segment下的table数组
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
//遍历table下的HashEntry链表
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}
put操作
ConcurrentHashMap初始化的时候，会初始化Segment[0],其他的Segment在插入第一个值的时候才会初始化
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
//定位所需要的hash值
int hash = hash(key);
//定位到元素在Segment[]数组中的位置
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject
(segments, (j << SSHIFT) + SBASE)) == null)
//初始化Segment[j],因为整个map初始化的时候，只初始化了segment[0]
s = ensureSegment(j);
//把元素放到对应的Segment元素中
return s.put(key, hash, value, false);
}
s = ensureSegment(j);
多个线程进入同一个Segment[k]，只要有一个成功就行了，使用CAS保证并发
s.put(key, hash, value, false);
Segment.put方法会舱室获得锁，如果没有获得所，调用scanAndLockForPut方法自旋等待获得锁
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
scanAndLockForPut通过while自旋获取锁
private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
。。。
while (!tryLock()) {
。。。
}
return node;
}
获取锁之后，如果摸个HashEntry节点有相同的key，就更新HashEntry的value值；否则新建已给HashEntry节点，采用头插法把他设置为链表的新head节点，并将原节点设置为head的下一个节点
新建过程中如果节点数超过threshold，就会调用rehash()对Segment中的数组进行扩容
扩容rehash操作：对table扩容
对table扩容成两倍的时候，有些值在数组中的下标未变，有些值会变化为i+capacity，举例如下
原table长度是capacity=4，元素在table中位置
| hash值 | 15 | 23 | 34 | 56 | 77 |
| 在table中下标 | 3=15%4 | 3=23%4 | 2=34%4 | 0=56%4 | 1=77%4 |
扩展一倍之后,通过这个方法，可以快速定位和减少元素重拍的次数
| hash值 | 56 | 34 | 77 | 15,23 | ||||
| 下标 | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| 计算 | i | i | i+capacity=1+5=5 | i+capacity=3+4=7 |
remove操作
和put方法类似，都是在操作之前要拿到锁，以保证操作的线程安全性
ConcurrentHashMap的弱一致性
遍历链表中是否有形同key以获得value。但是由于遍历过程中，其他线程可能对链表结果做了调整，因此get和containsKey方法返回的可能是已经过时的数据，这一点是ConcurrentHashMap在弱一致性上的体现。如果要求强一致性，那么必须使用Conllections.synchronizedMap()方法
在多线程下避免使用size、containsValue方法
在循环的方法判断两次，每个Segment中所有元素个数的和两次相等才返回值，否则循环次数超过预定义值，就会对Segment进行加锁，影响性能
在1.8下ConcurrentHashMap实现分析
1.8对ConcurrentHashMap的改进
1、取消Segment字段，直接采用transient volatile HashEntry<K,V>[] table保存数据，直接采用table数组元素作为锁，从而实现了缩小锁的粒度，提高了效率
2、原来是table数组+单项链表；现在是table数组+单向链表+红黑树结构（因为如果某一个链表数据过长，单链表查询就必须一个个遍历，效率低，数据多的时候，把链表转换为红黑树，可以提高查询效率，数据少的时候，红黑树会降级为普通链表）
链表使用Node节点，红黑树使用TreeNode节点
图解
核心数据结构和属性
参数：
static final int TREEIFY_THRESHOLD = 8; |
将链表转换为红黑树的阈值 |
static final int UNTREEIFY_THRESHOLD = 6; |
判断将红黑树转换成链表的阈值 |
node
node是最核心的内部类，他包装了key-value键值对
static class Node<K,V> implements Entry<K,V> {
final int hash;
final K key;
volatile V val;
volatile Node<K,V> next;
map本身持有一个node型的数组
transient volatile Node<K,V>[] table;
TreeNode
树节点，当链表长度>=8,就会转换成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;
与1.8中HashMap不同
1、并不是直接转换为红黑树，而是把这些节点放在TreeBin对象中，有TreeBin完成对红黑树的包装
2、TreeNode扩展自ConcurrentHashMap中Node类，而并非HashMap中的LinkedHashMap.Entry<K,V>类，也就是说TreeNode带有next指针
TreeBin
负责TreeNode节点。他代替了TreeNode的根节点，也就是说在实际的ConcurrentHashMap数组中，存放的是TreeBin对象，而不是TreeNode对象，另外这个类还带有了读写锁机制。
static final class TreeBin<K,V> extends Node<K,V> {
TreeNode<K,V> root;
volatile TreeNode<K,V> first;
volatile Thread waiter;
volatile int lockState;
// values for lockState
static final int WRITER = 1; // set while holding write lock
static final int WAITER = 2; // set when waiting for write lock
static final int READER = 4; // increment value for setting read lock
特殊的ForWardingNode
一个特殊的Node节点，hash=-1，其中存储nextTable的引用。有table发生扩容的时候，ForWardingNode发挥作用，作为一个占位符放在table中表示当前节点为null或者已经被移动
static final class ForwardingNode<K,V> extends Node<K,V> {
final Node<K,V>[] nextTable;
ForwardingNode(Node<K,V>[] tab) {
super(MOVED, null, null, null);
this.nextTable = tab;
}
sizeCtl：用来控制table的初始化和扩容操作
private transient volatile int sizeCtl;
| 负数 | 正在初始化或者扩容操作 |
| -1 | 正在初始化 |
| -N | 代表有N-1个线程正在进行扩容操作 |
| 0默认值 | 代表还没有被初始化 |
| 正数 | 表示初始化大小或者Map中的元素叨叨这个数量是，需要进行扩容了 |
核心方法
/*利用硬件级别的原子操作，获得在i位置上的Node节点
* Unsafe.getObjectVolatile可以直接获取指定内存的数据，
* 保证了每次拿到数据都是最新的*/
static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
/*利用CAS操作设置i位置上的Node节点*/
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);
}
/*利用硬件级别的原子操作，设置在i位置上的Node节点
* Unsafe.putObjectVolatile可以直接设定指定内存的数据，
* 保证了其他线程访问这个节点时一定可以看到最新的数据*/
static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
}
构造方法
可以看到，值是简单的属性设置，并没有初始化table，只有在put、computeIfAbsent、conpute、merge等方法的时候，检查table==null，才开始初始化
public ConcurrentHashMap18(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);
this.sizeCtl = cap;
}
get操作
get方法查找的时候，对于在链表和红黑树上，需要分别去查找
public V get(Object key) {
Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
int h = spread(key.hashCode());/*计算hash值*/
/*根据hash值确定节点位置*/
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
/*Node数组中的节点就是要找的节点*/
if ((eh = e.hash) == h) {
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
return e.val;
}
/*eh<0 说明这个节点在树上 调用树的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;
}
put操作
首先根据hash值计算插入点在table中的位置i，如果i位置是空的，还没有存放元素，直接当做链表节点放进去，否则要判断，如果table【i】是红黑树节点，就要按照树的方式插入新的节点，否则把i插入到链表的末尾。
如果是链表，加入元素之后，链表长度大于等于8，就要把链表装换为红黑树。
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());/*计算hash值*/
int binCount = 0;
/*死循环 何时插入成功 何时跳出*/
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();/*如果table为空的话，初始化table*/
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
/*Node数组中的元素，这个位置没有值 ，使用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 {
V oldVal = null;
/*锁Node数组中的元素，这个位置是Hash冲突组成链表的头结点
* 或者是红黑树的根节点*/
synchronized (f) {
if (tabAt(tab, i) == f) {
/*fh>0 说明这个节点是一个链表的节点 不是树的节点*/
if (fh >= 0) {
binCount = 1;
for (Node<K,V> e = f;; ++binCount) {
K ek;
/*put操作和putIfAbsent操作业务实现*/
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
if (!onlyIfAbsent)
e.val = value;
break;
}
Node<K,V> pred = e;
/*如果遍历到了最后一个结点，使用尾插法,把它插入在链表尾部*/
if ((e = e.next) == null) {
pred.next = new Node<K,V>(hash, key,
value, null);
break;
}
}
}
/*按照树的方式插入值*/
else if (f instanceof TreeBin) {
Node<K,V> p;
binCount = 2;
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
oldVal = p.val;
if (!onlyIfAbsent)
p.val = value;
}
}
}
}
if (binCount != 0) {
/*达到临界值8 就需要把链表转换为树结构*/
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
/*Map的元素数量+1，并检查是否需要扩容*/
addCount(1L, binCount);
return null;
}
initTable初始化table
在构造函数中并没有初始化ConcurrentHashMap，初始化时发生在向map中插入元素的时候
private final Node<K,V>[] initTable() {
Node<K,V>[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
/*小于0表示有其他线程正在进行初始化操作，把当前线程CPU时间让出来。
因为对于table的初始化工作，只能有一个线程在进行。*/
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) {
int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
@SuppressWarnings("unchecked")
Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
table = tab = nt;
/*n右移2位本质上就是n变为n原值的1/4，所以
* sc=0.75*n */
sc = n - (n >>> 2);
}
} finally {
/*将设置成扩容的阈值*/
sizeCtl = sc;
}
break;
}
}
return tab;
}
多线程扩容transfer方法
并发扩容，减少扩容带来的时间影响
1、构建一个是原来容量两倍的newTable
2、数据从table复制到newTable
remove
移除方法基本流程和put方法类似，如果是红黑树，会检查容量是不是<=6,是：红黑树就会转换为链表
treeifyBin
用于将过长的链表转换为TreeBin对象。但是他不是直接转换，而是进行容量判断，如果容量没有达到转化的要求。直接返回。与hashmap
不同的是他并没有把TreeNode直接放入红黑树，而是利用了TreeBin这个笑容起来封装素有的TreeNode
size
在扩容和addcount()的时候，size就已经计算好了，需要size会直接返回，这样节省了时间。（jdk7还要实时计算才能够得到size大小）