Java并发---ConcurrentHashMap和CopyOnWriteArrayList

• 1、ConcurrentHashMap
• • 1.1、jdk1.7的ConcurrentHashMap
  • 1.2、jdk1.8的ConcurrentHashMap
  • • 1.2.1、jdk1.8HashMap的协助扩容
• 2、CopyOnWriteArrayList

jdk1.7的 ConcurrentHashMap 的数据结构是在真正的hashMap外层又套了一层数组，这样子就相当于把一整个hashmap分割了，使用了分段锁，在一个数据put进来时，会先去获取 segment 这把锁，然后获取到了才能写数据，如下图所示：

jdk1.8中是基于分段锁和cas对并发的不安全性做了控制，采取了无锁状态，效率比1.7提高了不少，代码如下：
我们可以看到代码中这个方法 casTabAt 就是对多线程情况下写数据的控制，后面就是链表和红黑树的构建了。
过程大概如下：
1、如果数组hashMap未初始化，则初始化。
2、循环使用cas算法去竞争写入数据，一次只能有一个线程竞争成功，多次循环，直至将节点放进去。
3、如果第一次未竞争成功，第二次循环发现数组正在扩容，会协助扩容，详情请看1.2.1。
4、在cas替换的时候，tabAt(tab, i = (n - 1) & hash)就是返回当前需要写入数据的那一列，锁住当前要构建链表或红黑树的那一列，防止节点丢失。
5、如果符合链表条件，就构建链表，如果符合红黑树条件就构建红黑树。

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[] tab = table;;) {
        Node f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        // 这里是当多个线程竞争一个槽位时，进入这个逻辑
        // 假设此时有两个线程T1和T2，T1竞争成功了，T2再次循环就得走下面逻辑了
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
        	// 使用cas算法，只能有一个将数据写入成功
            if (casTabAt(tab, i, null,
                         new Node(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 要写入数据的时候发现hashmap正在扩容，就会发生8.2.1的扩容协助
        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 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 pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 构建红黑树
                    else if (f instanceof TreeBin) {
                        Node p;
                        binCount = 2;
                        if ((p = ((TreeBin)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;
}

扩容协助的意思就是当多个线程去往槽位中插入节点时，当在执行第一轮循环时发现槽位已被占用，执行第二轮循环时发现当前的HashMap正在扩容，这个时候当前线程就会协助扩容，会给它分16个槽位，去复制原先的数据。
就是上面代码的这块：

// 要写入数据的时候发现hashmap正在扩容，就会发生8.2.1的扩容协助
else if ((fh = f.hash) == MOVED)
    tab = helpTransfer(tab, f);

CopyOnWriteArrayList是一种读写分离，空间换时间，避免为保证并发安全导致的激烈的锁竞争的线程安全的数组。
应用场景：读多写少的场景下。
add方法流程： 在add一个数据时，会将原来的数组复制一份，复制的这一份会比原来的数组长度大1并加锁，同一时间只能有一个线程去复制数组，原来的数组现在就只用于读，新数组用来写，所以是读写分离，写完之后，会丢弃掉原来数组，将新数组作为当前数组，代码如下：

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // 复制一份并加1
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;
        // 丢弃原来的数组
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}