synchronizedList和CopyOnWriteArrayList

1.synchronizedList

synchronizedList能把所有 List 接口的实现类转换成线程安全的List，相比 Vector 有更好的扩展性和兼容性

    public void test(){
        ArrayList<String> list = new ArrayList<>();
        List<String> synchronizedList = Collections.synchronizedList(list);
        synchronizedList.add("a");
        synchronizedList.add("b");
        synchronizedList.forEach(System.out::println);
        synchronizedList.remove("a");
    }

而synchronizedList在源码中，大部分的方法都加上了带同步对象锁，因此在读多些少的情况，性能很一般。

public E get(int index) {
    synchronized (mutex) {return list.get(index);}
}
public E set(int index, E element) {
    synchronized (mutex) {return list.set(index, element);}
}
public void add(int index, E element) {
    synchronized (mutex) {list.add(index, element);}
}
public E remove(int index) {
    synchronized (mutex) {return list.remove(index);}
}

2.CopyOnWriteArrayList

CopyOnWriteArrayList：先复制再写入，就是在添加元素的时候，先把原数据复制一份，在执行完修改操作后将原来集合指向新的集合来完成修改操作。

CopyOnWriteArrayList在读取时不会加锁

    private E get(Object[] a, int index) {
        return (E) a[index];
    }

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

而在写入时，先加锁，再进行复制替换操作，最后再释放锁。

    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);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

读取元素时就不用加锁，写数据时加锁，在并发条件下，读取性能较好，但对于写多读少的情况下，效率则一般。

总结：

synchronizedList：适合对数据实时性准确性要求较高的情况下使用，此外因为读写全都加锁，性能较为一般。
CopyOnWriteArrayList：写加锁，读不加锁，因此读取效率较高，适合读多写少的场景，但因为在读的时候读的是旧集合，所以它的实时性不高。