@TOC
为什么面试会问ConcurconrentHashMap
又是我，我又回来了，哇咔咔！
追根溯源
跟你们讲，之前看了写的那个HashMap，一般的小问题都难不住，但这个时候就会有一个大问题产生，那就是面试官特别喜欢顺着你问，一旦问到你HsahMap线程安全的时候，就是一个平底锅警告，因为你指定会说线程不安全，然后说几个线程安全的map实现类，像是HsahTable，ConcurconrentHashMap，然后就是Collentions辅助工具类里的synchronizedMap，这个是传进去一个map，每次获取对象的时候加synchronized锁，锁性能和HashTable差不多。 这三个线程安全的map中，ConcurconrentHashMap是使用最多的，也是三者中效率最高的，也是实现最复杂的，所以要是想要高money，这个就要会，同时面试官也会很自然的问道你这里，接收审判吧。
情景再现
面试官：看你HashMap掌握的这么好，一定是看了充三毛钱电费的博客了吧 我：那你看，尤其是这篇HashMap的博客写的非常棒！ blog.csdn.net/qq_42828912…. 面试官：那你知道那些线程安全的map嘛？ 我：HsahTable，ConcurconrentHashMap和Collentions辅助工具类里的synchronizedMap 面试官：那你说说ConcurconrentHashMap的底层实现吧。 我：好的，ConcurconrentHashMap嘛，你看它名字字母这么多，这么长，这么绕口，一定有它突出的地方，所以它是线程安全的，比HashMap强。 面试官：说的有理有据，不卑不亢，非常好，出门左拐直走就有地铁，不报销路费的哦！ 我：漂亮！
ConcurconrentHashMap的底层实现原理
ConcurconrentHashMap底层可有老多东西了，1.7版本ConcurconrentHashMap底层采用的是分段锁，1.8版本优化为CAS+synchnoized的方式，这里咱们就之说1.8，车门都给我焊死，不榨干你们的脑细胞谁都不许下车。
这回不讲内部定义的常量了
ConcurrentHashMap的底层结构和HashMap一样，都是数组+链表+红黑树，所以有些定义的常量都是相同，还有一些特定的并发有关的常量，深度太深就不写了，主要是我也不会。给你们看一眼吧。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;//默认并发数
private static final int MIN_TRANSFER_STRIDE = 16;; //转移最小值
private static int RESIZE_STAMP_BITS = 16;;//生成sizeCtl所使用的bit位数
private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;;//进行扩容所允许的最大线程数
private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;;//记录sizeCtl中的大小所需要进行的偏移位数
//下面是几个标识
static final int MOVED = -1; // hash for forwarding nodes
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
复制代码跟你们讲，来我这不是看你们想知道啥，而是看我会啥，我就挑我会的说吧。
public class ConcurrentHashMap<K,V> extends AbstractMap<K,V>
implements ConcurrentMap<K,V>, Serializable {
复制代码和 HashMap一样继承了AbstractMap，可序列化，不同的是他实现的ConcurrentMap接口。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
volatile V val;//这里
volatile Node<K,V> next;//这里
Node(int hash, K key, V val, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.val = val;
this.next = next;
}
复制代码可以看见相比于HashMap，ConcurrentMap的Node在value和下个节点都加上了volatile，以保证val的可见性。（volatile不会的等我更新) get的两个方法都没
public ConcurrentHashMap() {
}
复制代码但我们new ConcurrentMap（）可以看到初始化的时候是一个空实现，这是一个ConcurrentMap特有的点，下面就能提到这里为什么是空的，往下看吧。
put（）方法详解
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
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();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
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;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {
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;
}
}
}
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) {
if (binCount >= TREEIFY_THRESHOLD)
treeifyBin(tab, i);
if (oldVal != null)
return oldVal;
break;
}
}
}
addCount(1L, binCount);
return null;
}
复制代码怎么这么这么这么这么这么这么这么这么这么这么这么这么这么这么这么这么这么这么这么这么长啊，一点一点看吧。
public V put(K key, V value) {
return putVal(key, value, false);
}
/** Implementation for put and putIfAbsent */
final V putVal(K key, V value, boolean onlyIfAbsent) {
if (key == null || value == null) throw new NullPointerException();
int hash = spread(key.hashCode());
复制代码put()方法调用putval()方法，比hashmap的多了一个boolean类型的参数。 再看putval()方法，上来先判断key和value是否为空，hashmap没有这部，它允许null作为key，然后便是一个双重hash算法，估计都能猜到目的是什么，充分散列，减少hash冲突。
for (Node<K,V>[] tab = table;;) {
Node<K,V> f; int n, i, fh;//就是这里
if (tab == null || (n = tab.length) == 0)
tab = initTable();
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
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);
复制代码遍历hash桶，如果桶是空的就初始化，不是空的就找到对应的位置，如果对应位置没有元素，就直接CAS无锁插入，如果正在扩容，就先完成扩容。（CAS不会的一样等我更新）
Node<K,V> f; int n, i, fh;
if (tab == null || (n = tab.length) == 0)
tab = initTable();
复制代码这里就是上面构造方法没有进行初始化，在这里进行判断，空的话就调用initTable进行初始化，属于懒汉模式初始化。
else {
V oldVal = null;
synchronized (f) {
if (tabAt(tab, i) == f) {
if (fh >= 0) {//表示是链表
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;
}
}
}
复制代码如果上面的条件都不符合，就是说有了hash冲突，对应的位置上有元素，就要上锁，锁住链表或者红黑树的头节点，当key相同的时候，就会覆盖value值，不然就尾插法插在尾部。 剩下的就是红黑树，链表转红黑树判断，扩容判断，红黑树插入时会有旋转操作，剩下的就不说了。 总结一下就是
1.检查是否初始化，未初始化就调用initTable()方法初始化
2.判断key和value是否为空，不为空对key进行双重hash，充分散列
3.对应位无元素，直接CAS进行插入
4.扩容先完成扩容
5.产生hash冲突，加锁保证线程安全，链表的话就遍历链表到尾部插入，红黑树就按红黑树的接口插入
6.当链表长度大于8，node数量大于64，转成红黑树，再次循环。
7.扩容检验。
复制代码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());
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;
}
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;
}
复制代码get()方法看着就少了很多，但是不要高兴的太早，人家有自己的专属辅助方法find（），其实就是遍历节点找对应key（包含一个nextTable指针，用于指向下一张表，从nextTable里进行查询节点，而不是以自身为头节点进行查找） 老样子，上来双重hash，确定key的值，如果table不为空，就读取首节点弄node，如果是首届点就返回，当正在扩容的时候，就会调用find（）方法查照元素，既不是首节点，也米有扩容就继续往下遍历，知道找到对应key，找不到就返回空。
小结
看了这些底层就可以发现，1.8的ConcurrentHashMap结构非常接近HashMap，相比1.7的ConcurrentHashMap的分段锁，1.8的ConcurrentHashMap这种只调用synchronized锁住首节点的方式，使得锁更加灵活，同时锁粒度也更加小，更加
最后给你们推荐一本书吧
这里面基本都是我自己的理解，如果有错误请写在下面，跟我打一架！ 古德拜~