我们知道在java.util包下提供了一些容器类，而Vector和HashTable是线程安全的容器类，但是这些容器实现同步的方式是通过对方法加锁(sychronized)方式实现的，这样读写均需要锁操作，导致性能低下。
ConcurrentMap接口
ConcurrentMap接口继承了Map接口，在Map接口的基础上又定义了四个方法：
public interface ConcurrentMap<K, V> extends Map<K, V> {
//插入元素，与原有put方法不同的是，putIfAbsent方法中如果插入的key相同，则不替换原有的value值；
V putIfAbsent(K key, V value);
//移除元素，与原有remove方法不同的是，新remove方法中增加了对value的判断，如果要删除的key-value不能与Map中原有的key-value对应上，则不会删除该元素;
boolean remove(Object key, Object value);
//替换元素，增加了对value值的判断，如果key-oldValue能与Map中原有的key-value对应上，才进行替换操作；
boolean replace(K key, V oldValue, V newValue);
//替换元素，与上面的replace不同的是，此replace不会对Map中原有的key-value进行比较，如果key存在则直接替换；
V replace(K key, V value);
}
ConcurrentHashMap类
ConcurrentHashMap同HashMap一样也是基于散列表的map，但是它提供了一种与HashTable完全不同的加锁策略提供更高效的并发性和伸缩性。
ConcurrentHashMap提供了一种粒度更细的加锁机制来实现在多线程下更高的性能，这种机制叫分段锁(Lock Striping)。
提供的优点是：在并发环境下将实现更高的吞吐量，而在单线程环境下只损失非常小的性能。
可以这样理解分段锁，就是将数据分段，对每一段数据分配一把锁。当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问。
有些方法需要跨段，比如size()、isEmpty()、containsValue()，它们可能需要锁定整个表而而不仅仅是某个段，这需要按顺序锁定所有段，操作完毕后，又按顺序释放所有段的锁。如下图：
ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。Segment是一种可重入锁ReentrantLock，HashEntry则用于存储键值对数据。
一个ConcurrentHashMap里包含一个Segment数组，Segment的结构和HashMap类似，是一种数组和链表结构， 一个Segment里包含一个HashEntry数组，每个HashEntry是一个链表结构（同HashMap一样，它也会在长度达到8的时候转化为红黑树）的元素， 每个Segment守护者一个HashEntry数组里的元素，当对HashEntry数组的数据进行修改时，必须首先获得它对应的Segment锁。
ConcurrentHashMap的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) {
// key 和 value都不能为空
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();
// 根据hash，取table上相应位置的第一个结点f，判断它是否为空
else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
// 如果为空，用cas添加进去
if (casTabAt(tab, i, null,
new Node<K,V>(hash, key, value, null)))
break; // no lock when adding to empty bin
}
// 如果当前节点是一个forwarding节点，表示在resize过程中
else if ((fh = f.hash) == MOVED)
// 如果在resize过程中，帮助转换
tab = helpTransfer(tab, f);
// 检查第一个没有申请锁的结点
else {
V oldVal = null;
// 以第一个结点为锁
synchronized (f) {
// 如果f是第一个结点
if (tabAt(tab, i) == f) {
if (fh >= 0) {
binCount = 1;
// 死循环，每次binCount加1
for (Node<K,V> e = f;; ++binCount) {
K ek;
// 如果当前节点的hash等于key的hashCode，
// 且当前节点的key equals key
if (e.hash == hash &&
((ek = e.key) == key ||
(ek != null && key.equals(ek)))) {
// 说明key已经存在，获取原来的值
oldVal = e.val;
if (!onlyIfAbsent)
// 替换这个节点的值
e.val = value;
break;
}
Node<K,V> pred = e;
// 如果弄到最后还是为空，说明key不存在
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;
// 调用红黑树的put方法，其内部也是使用的CAS，并判断key是否已存在
if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
value)) != null) {
// key存在，得到原来值
oldVal = p.val;
if (!onlyIfAbsent)
// 设置新值
p.val = value;
}
}
}
}
// 如果binCount不为0，插入成功了，否则会进入再一次的循环
if (binCount != 0) {
// 如果大于转换红黑树的阈值
if (binCount >= TREEIFY_THRESHOLD)
// 转换成红黑树，内部以根结点为锁
treeifyBin(tab, i);
/ 如果key已存在，有原值，返回原值
if (oldVal != null)
return oldVal;
break;
}
}
}
// 元素计数加1，根据binCount来检验是否需要检查和扩容
// 如果<0，不会检查。这里不会小于0
// 如果<=1，会检查uncontended。
// 如果>1，会检查并尝试扩容
addCount(1L, binCount);
return null;
}
总结一下put的过程：
- 先检查key和value都不能为空，如果为空，就抛出空指针异常；
- 对key再哈希，防止用户自己写的哈希算法导致分布不均匀；
- 检查是否已经进行了初始化，如果没有，要先初始化；
- 根据再hash的值，计算在table上的位置的第一个结点f，如果f为空，用CAS直接插入；否则，进行第5步；
- 检查f是否是一个forwarding结点，如果是表示正在扩容，当前线程就去帮助扩容；如果不是，进行第6步；
- 检查f的key是不是等于要插入的key，如果是，获取原来的值并替换成新的值，如果不是，进行第7步；
- 以第一个结点为锁；
- 如果f不是红黑树结点，进行第9步，如果是红黑树结点，进行第11步；
- 根据链表向下找，如果找到key相等的位置，获取原来的值并替换成新的值；
- 如果一直到链表末尾也没有找到相等的key，就在链表尾部插入一个新节点；
- 调用红黑树的putTreeVal方法，其内部是使用CAS，也会判断key是否已经存在并返回旧值；
- 如果是保留的Node类型ReservationNode，直接抛出异常；
- 根据binCount判断是否达到链表转红黑树的阈值，如果达到了，转成红黑树，这个过程会以根节点为锁；
