2019独角兽企业重金招聘Python工程师标准>>> 
并发包里面ConcurrentHashMap是一个使用频率，面试频率都是用到比较高的。今天我们就剖析一下ConCurrentHashMap的源码。我们还是使用场景驱动的方式去分析。
- 构建函数
但是发现构造函数进去以后就是一个无参的构造，没什么特别的。
2.分析put流程
put流程是整个ConCurrentHashMap的精华部分,里面淋漓尽致的使用了分段加锁的思想。
3.分析get流程
Get是一个读流程，采用的也是无锁化方式，但是方法调的底层的unsafe的方法保证了可见性。整个ConCurrentHashMap的性能很高。
ConcurrentHashMap map = new ConcurrentHashMap();
//剖析写数据流程
map.put("test","zhangsan");
//剖析读数据流程
map.get("test")
接着我们分析一下put的方法，这个方法非常重要。体现了整个ConCurrentHashMap的设计精髓。Put点进去以后是这个方法
public V put(K key, V value) {
//重要，点进去以后继续分析
return putVal(key, value, false);
}
final V putVal(K key, V value, boolean onlyIfAbsent) {
//如果key或者value其中一个null，就报空指针异常
if (key == null || value == null) throw new NullPointerException();
//取hash值，但是我们注意的是，这儿并不是直接用的key的hashCode值。
//而是调用了spred方法。
//spread里的关键代码是(h ^ (h >>> 16)) & HASH_BITS;
//用当前的hashCode值向右移了16位，然后再做异或
//这样操作的出来的值都保留着着hashCode的高低16位的特征，减少hash冲突
//所以我们这儿要知道。这儿的hash值不是直接用的hashCode
int hash = spread(key.hashCode());
int binCount = 0;
for (Node[] tab = table;;) {
Node f; int n, i, fh;
//如果当前的tab里面没有数据
if (tab == null || (n = tab.length) == 0)
//初始化table,然后进去下一轮循环
tab = initTable();
//进入下一轮循环以后走到这儿。
//return (Node)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
//这儿就是计算index的位置，使用tabAt的方法查找对应位置的数据
//如果对应位置的数据是null，说明我们要插入的这个位置目前还没有数据
//注意这儿使用的是unsafe的getObjectVolatile，也就是说，这个是具有可见性的
//如果并发的时候有人修改了这个值，对这个操作也是课件。
//如果有同学看过我之前分析过《从硬件层面聊聊synchonzied和volatile》
//应该知道volatile这儿相当于是加了load屏障，在获取数据的时候，如果在无效队列里面发
//现数据无效，就会重新加载。
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//如果当前位置没有元素，直接就通过cas进行插入元素。
//cas操作的代码是
//return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
//其实这个cas操作在硬件层面是加锁的，所以这儿其实是线程安全的。这点大家一定
//要知道。
//那么这儿我们还可以继续分析一下，如果这儿同时两个线程并发进来操作
//必然有一个成功的，一个是失败了，成功的，当然就添加了数据了。
//其实这个地方分段加锁的思想已经出来了，因为我们分析指导
//针对表的一个位置，我们采用的cas的机制，这个时候，只有针对同一个位置
//才会插入失败。但是其余的位置照样可以进行cas的操作。换句话说一个位置一把锁
//因为是for循环，所以失败了的那个肯定再次循环。
//但是因为这个位置已经有数据了。所以代码不走这儿了。
if (casTabAt(tab, i, null,
new Node(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
//其实这儿也就体现了分段加锁的思想。一个Node就一把锁
synchronized (f) {
//f其实就是前面要加锁的时候，获取出来的node
//其实如果代码走到这儿，代表的就是tabAt(tab, i) == f
//但是这儿还要继续判断就是为了一个严谨
//因为就怕中间有人修改过这个f这个node
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
for (Node e = f;; ++binCount) {
K ek;
//如果插入的key和value
//key是一样的并且value不为空
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
oldVal = e.val;
//直接就覆盖
if (!onlyIfAbsent)
e.val = value;
break;
}
//代码走到这儿，只能说明是
//key不一样，只不过是巧了，虽然key不一样
//但是经过hash运算以后，当前key定位了一个
//已经有数据的位置上。
Node pred = e;
if ((e = e.next) == null) {
//直接就在当前node上挂载 一个node节点
//注意，一个节点上挂载的节点超过8个
//就会变化为红黑树
pred.next = new Node(hash, key,
value, null);
//挂载成功以后就退出
break;
}
}
}
//如果当前定位到的Node已经变成是红黑树
//那么就选择使用红黑树的方式插入数据
else if (f instanceof TreeBin) {
Node p;
binCount = 2;
if ((p = ((TreeBin)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;
}
}
}
//计算node上挂载的节点个数
addCount(1L, binCount);
return null;
}
private final Node[] initTable() {
Node[] tab; int sc;
while ((tab = table) == null || tab.length == 0) {
if ((sc = sizeCtl) < 0)
Thread.yield(); // lost initialization race; just spin
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[] nt = (Node[])new Node[n];
table = tab = nt;
sc = n - (n >>> 2);
}
} finally {
sizeCtl = sc;
}
break;
}
}
return tab;
}
上面我们分析了写入数据的时候加锁的思想，接下来我们分析一下，ConcurrentHashMap
读数据的时候又是什么情况？
public V get(Object key) {
Node[] tab; Node e, p; int n, eh; K ek;
//计算位置
int h = spread(key.hashCode());
//这个条件判断，如果table里是有数据的，并且根据当前
//key计算出来的位置也是有数据的
if ((tab = table) != null && (n = tab.length) > 0 &&
(e = tabAt(tab, (n - 1) & h)) != null) {
//如果是hash值相同
if ((eh = e.hash) == h) {
//如果是key相同
if ((ek = e.key) == key || (ek != null && key.equals(ek)))
//那么我们直接返回当前的value值就行。
return e.val;
}
else if (eh < 0)
return (p = e.find(h, key)) != null ? p.val : null;
//如果代码走到这儿说明，要获取的key的对应
//hash位置确实是有数据的，对应位置的key跟传
//进来的key位置不一样,所以遍历列表
while ((e = e.next) != null) {
//直到遍历到 hash位置一样，key也一样位置。
//然后就把当前value值返回即可。
if (e.hash == h &&
((ek = e.key) == key || (ek != null && key.equals(ek))))
return e.val;
}
}
return null;
}
整个读的操作，我们分析其实是都没有加锁的。
不过我们注意到map里的元素我们是靠tabAt(tab, (n - 1) & h)这个方法获取到的。
static final Node tabAt(Node[] tab, int i) {
//调用了Unsafe的方法
//还保证了可见性。
return (Node)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
}
读这个操作保证了可见性，从硬件层面说，就是加了load屏障。所以在读数据的时候一定会嗅探一下，如果发现无效队列里面元素被人修改过。就会发送read消息到总线。从别的高速缓存里或者是主内存里读取数据。不加锁，但是他通过volatile读，尽可能给你保证读到其他线程修改的最新的值。