趣谈ConcurrentHashMap
最近准备面试，一谈到java基础，大部分面试官上来就java数据结构素质三连：ArrayList与LinkedList区别，HashMap底层数据结构，ConcurrentHashMap为什么能保证线程安全。
刚毕业的应届生，或者基础不好程序员（比如：本尊，对没错就是我~），只了解皮毛，一稍微深入就gg思密达。面试官：嗯...回头等通知吧~ 基本一首《凉凉》送我到门外了。
不好意思，扯远了！ 前两个问题很简单，一个数组一个链表。
数组顺序存储，内存连续，查询快，插入删除效率稍微低（System.copyArray），不过现在略有改善。
链表插入删除快速高效，查询效率差了点意思，存储不连续。
总之，各有利弊吧，根据业务场景选择适合自己的存储结构，不过现在也出现很多类似的改进版本，暂时不谈了（其实我也没了解过，啊哈哈哈~有点尴尬）
HashMap JDK1.8以前基本都是数组＋链表实现，JDK1.8开始改为数组+列表，当列表长度大于某个值（具体忘了），链表转化为一个X爆了的数据结构————红黑树（我都吓尿了反正，看了几百遍没记住这玩意各种算法）
其实今天主要是想聊一下这个叫做ConcurrentHashMap的数据结构，看过网上几篇文章实在是看的蛋疼，一来写的一般，对于源码的复制粘贴，最为我看起来吃力；二来红黑树太难，看着难受的一比。是在无法理解这个数据结构的精髓所在，故而想自己写篇文章来记录自己学习的过程，就好比孙悟空去了一趟五指山下，做个标记！
废话少说直接先上jb：
如图所示，相比传统HashMap，jdk1.8之前 ConcurrentHashMap 在传统HashEntry之前增加了一个segment数组。Segment数组的意义就是将一个大的table分割成多个小的table来进行加锁，Segment数组中每一个元素就是一把锁，每一个Segment元素存储的是HashEntry数组+链表。而在jdk1.8开始，ConcurrentHashMap是由CAS和Synchronized的方式去实现高并发下的线程安全。
我们主要从的get，put等方法来学习ConcurrentHashMap，是如何插入和获取元素，以及如何保证线程安全。
先看下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;
}我看上面的代码好多中间变量，很影响我这种菜鸟分析逻辑，于是我按照自己的编码风格，重写了一下：
public V get(Object key) {
int h = (key.hashCode() ^ (key.hashCode() >>> 16)) & 0x7fffffff;// 2 ^31 -1
Node<K,V>[] tab = table;
// 一般对哈希表的散列很自然地会想到用hash值对length取模（即除法散列法）
// Hashtable中也是这样实现的，这种方法基本能保证元素在哈希表中散列的比较均匀，
// 但取模会用到除法运算，效率很低，HashMap中则通过h&(length-1)的方法来代替取模，
// 同样实现了均匀的散列，但效率要高很多，这也是HashMap对Hashtable的一个改进。
Node<K,V> e = tabAt(tab, (tab.length - 1) & h);
if (tab == null || tab.length <= 0 ||e == null) {
return null;
}
if (e.hash == h) {
if (e.getKey() == key || (e.getKey() != null && key.equals(e.getKey()))){
return e.getValue();
}
} else if (e.hash < 0) {
Node<K,V> p = e.find(h, key);
return p!= null ? p.getValue() : null;
}
e = e.next;
while (e != null) {
if (e.hash != h) {
return null;
}
if (e.getKey() == key || (e.getKey() != null && key.equals(e.getKey())))
return e.getValue();
}
return null;
}int h = (key.hashCode() ^ (key.hashCode() >>> 16)) & 0x7fffffff;// 2 ^31 -1
代码的意思————通过哈希值二进制异或该哈希值二进制右移动16位 是为了计算哈希值 再和 上面那玩意进行与运算并不知道是什么鬼。如下图：
计算出Hash值之后要通过hash值找到对应数组的下标进而找到数组元素：
Node<K,V> e = tabAt(tab, (tab.length - 1) & h);
(tab.length - 1) & h 根据计算出来的hash值从HashMap的“骨干”——bucket数组找到对应的bucket
java.util.HashMap （ConcurrentHashMap同样）保证bucket数组的长度是2的幂方，所以本来应该写成：
index = n % length的，变为可以写成：index = n & (length - 1) ，“&”效率会高一点。
说了这么多我们来看下tabAt方法:
public static int numberOfLeadingZeros(int i) {
// HD, Figure 5-6
if (i == 0)
return 32;
int n = 1;
if (i >>> 16 == 0) { n += 16; i <<= 16; }
if (i >>> 24 == 0) { n += 8; i <<= 8; }
if (i >>> 28 == 0) { n += 4; i <<= 4; }
if (i >>> 30 == 0) { n += 2; i <<= 2; }
n -= i >>> 31;
return n;
}
U = sun.misc.Unsafe.getUnsafe(); // 获取unsafe类的实例 单例模式
@CallerSensitive
public static Unsafe getUnsafe() {
Class arg = Reflection.getCallerClass();//获取调用者方法的类
if (!VM.isSystemDomainLoader(arg.getClassLoader())) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}
Class<?> ak = Node[].class;
ABASE = U.arrayBaseOffset(ak);
int scale = U.arrayIndexScale(ak);
ASHIFT = 31 - Integer.numberOfLeadingZeros(scale);
@SuppressWarnings("unchecked")
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);
}