击碎java并发8JDK8挡板与ConcurrentHashMap

1 CountDownLatch

一种一次性挡板。线程到达挡板处后，会被阻塞，直到所有的相关线程都到达挡板处后，所有线程会被同时唤醒，接着往下执行。
源码非常简单。

2 CyclicBarrier

一种可以循环的CountDownLatch在代码中。可以设置循环额次数，并允许一轮循环结束后，执行完指定run方法，再去唤醒所有线程。
源码比较简单。

3 ConcurrentHashMap

大致上跟HashMap非常像，我之前看过hashMap的put方法源码，这里仅看并发部分，也会提一些。

3.1 算法与数据结构

3.1.1 HashTable

是一种存放元素的数组，每个数组由一个元素的链表构成。
通过对元素计算得到哈希值，再对哈希值做运算得到该元素在数组的下标（一般是通过求余数，被除数一般是数组的长度）。
得到数组下标以后，遍历链表存放元素。如果该哈希值已经存在，则覆盖元素（这就是哈希冲突也叫哈希碰撞）。

3.1.2 HashMap

是一种hashTable的优化：1.数组是可以扩容的。2.链表内元素高到一定数量时会转化为红黑树，在元素少到一定数量时会变成链表。

3.1.3 ConcurrentHashMap

是一种对HashMap的优化。使用分离锁，即每个链表或者红黑树，为一个锁。这是一个小优化。

3.2 重要方法putVal与putTreeVal

简直跟HashMap的一模一样，除了，除了刚才说的使用分离锁，即每个链表或者红黑树，为一个锁。这是一个小优化。
这里仅提一下在对树进行平衡操作的时候为什么要锁住树的根节点？为什么链表始终不用锁？

    /** Implementation for put and putIfAbsent */
    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) {
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    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;
    }

        /**
         * Finds or adds a node.
         * @return null if added
         */
        final TreeNode<K,V> putTreeVal(int h, K k, V v) {
            Class<?> kc = null;
            boolean searched = false;
            for (TreeNode<K,V> p = root;;) {
                int dir, ph; K pk;
                if (p == null) {
                    first = root = new TreeNode<K,V>(h, k, v, null, null);
                    break;
                }
                else if ((ph = p.hash) > h)
                    dir = -1;
                else if (ph < h)
                    dir = 1;
                else if ((pk = p.key) == k || (pk != null && k.equals(pk)))
                    return p;
                else if ((kc == null &&
                          (kc = comparableClassFor(k)) == null) ||
                         (dir = compareComparables(kc, k, pk)) == 0) {
                    if (!searched) {
                        TreeNode<K,V> q, ch;
                        searched = true;
                        if (((ch = p.left) != null &&
                             (q = ch.findTreeNode(h, k, kc)) != null) ||
                            ((ch = p.right) != null &&
                             (q = ch.findTreeNode(h, k, kc)) != null))
                            return q;
                    }
                    dir = tieBreakOrder(k, pk);
                }

                TreeNode<K,V> xp = p;
                if ((p = (dir <= 0) ? p.left : p.right) == null) {
                    TreeNode<K,V> x, f = first;
                    first = x = new TreeNode<K,V>(h, k, v, f, xp);
                    if (f != null)
                        f.prev = x;
                    if (dir <= 0)
                        xp.left = x;
                    else
                        xp.right = x;
                    if (!xp.red)
                        x.red = true;
                    else {
                        lockRoot();
                        try {
                            root = balanceInsertion(root, x);
                        } finally {
                            unlockRoot();
                        }
                    }
                    break;
                }
            }
            assert checkInvariants(root);
            return null;
        }