Java学习------ConcurrentHashMap

        ConcurrentHashMap 是 Java 集合框架中的一个线程安全的哈希表实现，位于 java.util.concurrent 包中。它是 HashMap 的线程安全版本，但提供了比 Hashtable 或Collections.synchronizedMap() 包装的 HashMap 更好的并发性能。

        在并发编程中，我们需要考虑线程安全问题。对于 HashMap 有以下几种传统线程安全方案：Hashtable：所有方法都用 synchronized 修饰，全局锁，性能差Collections.synchronizedMap()：同样使用全局锁手动同步：使用 synchronized 块或 Lock这些方案在高并发场景下性能都不理想，因为它们使用单一的全局锁，导致所有线程必须串行访问。而 ConcurrentHashMap 通过更细粒度的锁机制实现了更高的并发度。

        在 Java 7 中，ConcurrentHashMap 使用分段锁技术，其数据结构是由一个 Segment 数组组成，每个 Segment 是一个独立的哈希表，默认创建 16 个 Segment，理论上最多支持 16 个线程并发写入。其操作流程为：根据 key 的 hash 值确定 Segment，然后获取该 Segment 的锁，再在该 Segment 中执行操作，最后释放锁。

        在Java8版本中，对其进行了重大改革，其数据结构改为与 HashMap 类似的数组+链表+红黑树结构。并发控制该为了使用 CAS 无锁算法进行初始化、扩容等操作，然后对每个桶（数组元素）的第一个节点使用 synchronized 进行细粒度锁定。其取消分段锁，减少内存占用，并引入红黑树，解决哈希冲突时的性能问题，使用更多无锁操作提高并发性能。

        ConcurrentHashMap 的好处主要有：
（1）高并发性能：比 Hashtable 和 synchronizedMap 有更好的并发性能

                （2）线程安全：保证多线程环境下的数据一致性

                （3）读操作完全无锁：大多数情况下 get 操作不需要锁

                （4）写操作细粒度锁：只锁定当前操作的桶，不影响其他桶的操作

                （5）迭代弱一致性：迭代器反映创建时或之后的修改，但不保证反映所有最新修改

        但相对的，其也有不少缺点，主要有：
（1）内存占用：比 HashMap 占用更多内存（Java 7 的分段结构，Java 8 的额外计数器等）

                （2）size/isEmpty：结果可能不精确，因为并发环境下统计可能有延迟

                （3）复杂性：内部实现复杂，理解和使用需要更多知识

                （4）功能限制：不支持锁住整个表进行独占访问

        其有3个主要操作，分别是Put，Get，Size，

public V put(K key, V value) {return putVal(key, value, false);
}final V putVal(K key, V value, boolean onlyIfAbsent) {// 不允许key或value为nullif (key == null || value == null) throw new NullPointerException();// 计算key的hash值int hash = spread(key.hashCode());int binCount = 0;// 自旋插入节点for (Node<K,V>[] tab = table;;) {Node<K,V> f; int n, i, fh;// 情况1：table未初始化，先初始化if (tab == null || (n = tab.length) == 0)tab = initTable();// 情况2：计算出的桶位置为空，尝试CAS插入else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))break;  // 插入成功则退出循环}// 情况3：检测到正在扩容，帮助扩容else if ((fh = f.hash) == MOVED)tab = helpTransfer(tab, f);// 情况4：桶位置不为空，需要加锁处理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;// 找到相同key，替换valueif (e.hash == hash &&((ek = e.key) == key ||(ek != null && key.equals(ek)))) {oldVal = e.val;if (!onlyIfAbsent)e.val = value;break;}// 未找到相同key，添加到链表尾部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;
}
/*
采用自旋+CAS+synchronized的方式实现线程安全四种处理情况：初始化表、CAS插入新节点、协助扩容、加锁处理哈希冲突只在发生哈希冲突时对单个桶加锁，不影响其他桶的操作链表长度超过阈值(8)会转换为红黑树操作完成后会检查是否需要扩容*/

public V get(Object key) {Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;// 计算key的hash值int h = spread(key.hashCode());// table已初始化且对应桶不为空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;}// hash值为负表示特殊节点（正在扩容或是树节点）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;
}
/*  完全无锁：依赖volatile读和Node的不可变性保证线程安全处理三种情况：（1）直接命中桶的第一个节点（2）处理特殊节点（扩容或树节点）（3）遍历链表查找对于树节点，调用Node的find方法在红黑树中查找由于Node的val和next都是volatile的，可以保证可见性*/

public int size() {long n = sumCount();return ((n < 0L) ? 0 :(n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE :(int)n);
}final long sumCount() {CounterCell[] as = counterCells; CounterCell a;// 获取baseCountlong sum = baseCount;if (as != null) {// 累加所有CounterCell的值for (int i = 0; i < as.length; ++i) {if ((a = as[i]) != null)sum += a.value;}}return sum;
}