多线程环境下的ConcurrentHashMap

什么是ConcurrentHashMap？

ConcurrentHashMap并像HashMap一样在java.util包下，而是在java.util.concurrent包下，可见ConcurrentHashMap是为并发而存在的。ConcurrentHashMap是高并发环境下使用的HashMap，通过volatile、CAS、synchronized等来实现了线程安全的HashMap。

底层数据结构？

由于取消了segment，Java1.8中的ConcurrentHashMap跟HashMap的数据结构类似，参见上一篇HashMap。
Java1.8中引入了TreeBin来维护对桶内TreeNode的引用以及锁状态。

如何实现并发安全?

Java1.8中主要是通过CAS和synchronized来实现多线程安全的。
对于CAS有三个Table element access方法：

    @SuppressWarnings("unchecked")
    static final <K,V> Node<K,V> tabAt(Node<K,V>[] tab, int i) {
        return (Node<K,V>)U.getObjectVolatile(tab, ((long)i << ASHIFT) + ABASE);
    }

    static final <K,V> boolean casTabAt(Node<K,V>[] tab, int i,
                                        Node<K,V> c, Node<K,V> v) {
        return U.compareAndSwapObject(tab, ((long)i << ASHIFT) + ABASE, c, v);
    }

    static final <K,V> void setTabAt(Node<K,V>[] tab, int i, Node<K,V> v) {
        U.putObjectVolatile(tab, ((long)i << ASHIFT) + ABASE, v);
    }

put操作和HashMap一样还是使用putVal函数实现，不同的是，在当前位置无元素时，使用CAS来添加Node结点，如果失败，则继续循环，循环条件是
for (Node<K,V>[] tab = table;;)
直到CAS成功才break。
如果当前位置有元素，则对当前结点即头结点使用synchronized，缩小了锁的粒度。
get操作并没有加锁，并不能完全保证多线程的一致性。
size操作返回的也不是一个精确值。

    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;
        long sum = baseCount;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

transfer和ForwardingNode

transfer(Node<K,V>[] tab, Node<K,V>[] nextTab)是在扩容时使用的函数，它会将旧桶上的结点拷贝到新桶(Moves and/or copies the nodes in each bin to new table)。在结点中有一类Special Nodes。其中在transfer操作时插入到桶的头结点的特殊结点叫做ForwardingNode（A node inserted at head of bins during transfer operations）。可以把该结点称为转发结点，因为在扩容时，对旧table的访问，会有该结点转发到新table上。构造函数为：

 ForwardingNode(Node<K,V>[] tab) {
            super(MOVED, null, null, null);
            this.nextTable = tab;
 }

ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);

在transfer操作时，会调用此操作，

Hash计算

put时的hash计算借助了spread函数

    int hash = spread(key.hashCode());
    static final int spread(int h) {
        return (h ^ (h >>> 16)) & HASH_BITS;//HASH_BITS = 0x7fffffff;
    }