JUC_集合类

集合类

• 线程不安全解决方案

// 1. 使用Collections,使集合类变为线程安全的  
List<String> list1 = Collections.synchronizedList(new ArrayList<>());  
// 2. 使用Vector,不推荐,synchronized加锁解决的 
List<String> list2 = new Vector<>();  
// 3. JUC CopyOnWriteArrayList 使用lock
List<String> list3 = new CopyOnWriteArrayList<>();

• 写时复制(CopyOnWrite)
  CopyOnWriter容器即写时复制容器。往一个容器添加元素的时候，不直接往当前容器Object[ ]添加，而是先将当前容器Object[ ]进行copy,复制出一个新的容器Object[]，newElements，然后新的容器Object[ ] newElements 里面添加元素，添加元素之后，再将原容器的引用指向新容器 setArray(newElements)。这样做的好处是可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite是一种读写分离的思想，读和写不同的容器。

添加元素 写时复制

    /**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
        synchronized (lock) {
            Object[] es = getArray();
            int len = es.length;
            if (index > len || index < 0)
                throw new IndexOutOfBoundsException(outOfBounds(index, len));
            Object[] newElements;
            int numMoved = len - index;
            if (numMoved == 0)
                newElements = Arrays.copyOf(es, len + 1);
            else {
                newElements = new Object[len + 1];
                System.arraycopy(es, 0, newElements, 0, index);
                System.arraycopy(es, index, newElements, index + 1,
                                 numMoved);
            }
            newElements[index] = element;
            setArray(newElements);
        }
    }

读取元素 无锁

    /**
     * {@inheritDoc}
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return elementAt(getArray(), index);
    }


    final Object[] getArray() {
        return array;
    }

    static <E> E elementAt(Object[] a, int index) {
        return (E) a[index];
    }