相比HashMap而言，是多线程安全的，其底层数据与HashMap的数据结构相同。
JDK1.7之前通过对多个数组分段锁机制（Segment）来实现的加锁，默认16个Segment，16个分段，每个Segment对应Node[]数组，每个Segment有一把锁，也就是说对一个Segment里的Node[]数组的不同的元素如果要put操作的话，其实都是要竞争一个锁，串行化来处理的。
这种情况下，如果某一时间，同时并发访问同一个数组段，其最大并发度受段的个数限制，效率还是低。
JDK1.8后实现原理摒弃了这种设计，做了锁粒度的细化，一个大的数组，数组里每个元素进行put操作，都是有一个不同的锁，刚开始进行put的时候，如果当前位置为空，执行CAS操作设值。
如果两个线程都是在数组[5]这个位置进行put，这个时候如果里面的值不为null，对数组[5]这个位置进行put的时候，采取的是synchronized(f)加锁，锁住这个节点，只让一个线程来处理链表或红黑树。
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) {//如果当前位置没有值，就进入CAS操作，成功就结束
if (casTabAt(tab, i, null,new Node<K,V>(hash, key, value, null)))//多线程的时候不成功，进入下次for循环设值
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;
如果是get(key)的时候，是基于Unsafe.getObjectVolatile()，volatile读机制，来读取数组里的节点，而节点里面的value也是加了volatile，尽可能给你保证说是读到了其他线程修改的一个最新的值，但是不需要加锁volatile V val;
Volatile底部实现原理，关注我，后面会讲解。
ConcurrentHashMap和Hashtable的区别主要体现在实现线程安全的方式上不同。
1、HashTable内部的方法基本都经过 synchronized 修饰。而synchronized关键字加锁是对整个对象进行加锁，也就是说在进行put等修改Hash表的操作时，锁住了整个Hash表，从而使得其表现的效率低下。
2、ConcurrentHashMap主要从之前的分段加锁机制优化到现在的锁粒度的细化。
下篇开始讲解List集合相关特性及原理。
,
