为什么juc下的集合是线程安全、高效的？

我们常用的的java.util下的比如Arraylist、HashMap、HashSet虽然线程不安全，但执行效率很高，HashTable、Vector虽然线程安全(基于synchronized锁控机制)，但性能很低，而juc（java.util.concurrent）下的集合却可以保证既安全有高效，如：

ArrayList对应的高并发类是CopyOnWriteArrayList，
HashSet对应的高并发类是 CopyOnWriteArraySet，
HashMap对应的高并发类是ConcurrentHashMap。

下面通过源码看一下他们的实现原理：

1.CopyOnWriteArrayList其中的add方法：

 public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        lock.lock();//加锁
        try {
            Object[] elements = getArray();//创建了一个新数组
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);//copy了旧数组，并将数组长度增加一
            newElements[len] = e;//将e添加到新数组中
            setArray(newElements);//将修改后的数据替换原有的数据
            return true;
        } finally {
            lock.unlock();
        }
    }

可以看到当执行写操作时，先copy一份原有数据数组，再对复制数据进行写入操作，最后将复制数据替换原有数据，从而保证写操作不影响读操作。
同时，其复制的整个过程是上了锁的，所以不会产生多线程安全问题。
而加的锁ReentrantLock 相比Syncchronized具有以下功能：

1. 等待可终止：
   如果一个线程长期占有锁对象不释放，那么等待的线程可以选择停止等待，这样也避免了死锁的发生；
2. 公平锁：等待的线程必须按照申请的时间顺序去持有锁对象
3. 并不像synchronized那样要么唤醒一个线程，要么唤醒所有线程
   ，实现了可以分组唤醒需要唤醒的线程

2.CopyOnWriteArraySet与CopyOnWriteArrayList类似，只不过前面的数据无序，不可重复

3.ConcurrentHashMap其中的put方法：

public V put(K key, V value) {
        return putVal(key, value, false);
    }
    
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        //和hashMap不同的是，concurrentHashMap的key和value都不允许为null
        //concurrenthashmap它们是用于多线程的，并发的 ，如果map.get(key)得到了null，
        // 不能判断到底是映射的value是null,还是因为没有找到对应的key而为空，
        // 而用于单线程状态的hashmap却可以用containKey（key） 去判断到底是否包含了这个null。
        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;
            //如果是第一次put，进行初始化
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            //根据(tab.length - 1) & hash 计算目标节点在数组中的位置
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                //如果为空，则通过cas 添加一个新建一个头节点
                if (casTabAt(tab, i, null,
                             new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            //hash为-1 说明是一个forwarding nodes节点，表明正在扩容
            else if ((fh = f.hash) == MOVED)
                //帮助扩容
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                //对上面计算出来的节点进行加锁
                synchronized (f) {
                    //这里判断下有没有线程对数组进行了修改
                    if (tabAt(tab, i) == f) {
                        //这里如果hash值是大于等于0的说明是链表
                        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;
                            }
                        }
                    }
                }
                //如果链表数量大于TREEIFY_THRESHOLD（8），开始执行转换树
                if (binCount != 0) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        //进行元素数量统计，和决定是否扩容
        addCount(1L, binCount);
        return null;
    }

这里主要应用了锁分段的技术：
将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，put方法中首先就是通过算法找到负责这段数据的分段锁，

简而言之：JUC下的集合采用了读取操作时不加锁，而在修改数据时：
CopyOnWriteArrayList使用ReentrantLock这种互斥锁的特性(1.等待停止、2.公平锁、3.分组唤醒)避免了线程进入阻塞状态，从而达到高效
ConcurrentHashMap使用锁分段技术保证了数据的安全且高效；