在jdk1.8中，ConcurrentHashMap的实现完全抛弃了在之前版本中的Segment+HashEntry+链表的结构，转而采用和同期的HashMap相似的数组+链表/红黑树的结构。
重要的成员属性和结构
//节点数组
transient volatile Node<K,V>[] table;
//sizeCtl用于table[]数组的初始化和扩容操作
//-1:table数组正在初始化
//-N:当前有N-1个线程正在扩容
//正数：表示table数组将要进行初始化的大小，这在构造函数中会体现
private transient volatile int sizeCtl;
//Node类，只读的节点类，不提供修改节点的方法
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //final
final K key; //final
volatile V val; //volatile
volatile Node<K,V> next;//volatile
//这是一个修改value值的方法，但是会抛出异常
public final V setValue(V value) {
throw new UnsupportedOperationException();
}
}构造函数
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);
this.sizeCtl = cap;
}在构造函数中，只是进行了一系列容量和并发度的设置，并没有初始化table[]数组。但是设置了sizeCtl的值，该值表示下次进行扩容的时候，数组的长度。
put操作
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;
}- 判断table[]数组是否初始化了，如果没有，那么进行初始化
- 首先根据key.hashCode()计算出一个hash值，然后 hash & (n-1)计算出应该put的位置
- 判断位置i上是否有元素(是否 == null)，获取位置i上的元素的方法是一个基于Unsafe类实现的原子操作，是线程安全的
- 如果没有元素，那么直接构造一个Node插入就可以，这个插入的过程，是一个CAS操作，通过比较当前值是否等于给定的预期值
- 判断是否需要扩容
- 在链表或者红黑树中插入元素
- 判断是否需要将链表变成红黑树
在上述的操作中，执行链表或红黑树插入的操作需要加锁，使用的是synchronized关键字对节点Node进行加锁，而之前的操作都是无锁的操作，但是一样是线程安全的，因为使用了CAS操作，同样可以做到线程安全。
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;
}- 首先一样根据key.hashCode()计算处一个hash值，根据这个hash值得到需要找的数组的下标i
- 判断数组中该下标i处的元素的hash值是否 == key的hash值
- 如果等于的话，比较两者的关键字key(=或者equals)，如果结果为true，那么直接返回value
- 如果不等于，那么就需要在这个位置的节点上进行遍历
- 如果是红黑树，那么在树上查找
- 如果是链表，遍历链表
可以看出get()操作是没有加锁的。
为什么可以不加锁？
- 对Node节点来说，其value属性是一个volatile修饰的变量，对该种类型的变量而言，根据happens-before原则，volatile写要happens-before于volatile读，因此get()方法可以一直获取到最新被修改后的值，这是其一
- Node节点的next指针也是volatile修饰的，因此如果是发生了节点的更改，比如删除或者添加，get()操作也可以永远都读取到最新的值
- 从上面的分析可以看出，get()不加锁的原因，是基于volatile所具有的锁的内存语义来实现的