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为null
    if (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，替换value
                            if (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;
    // 获取baseCount
    long sum = baseCount;
    if (as != null) {
        // 累加所有CounterCell的值
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}