在上篇文章中我们已经介绍了其他的一些list集合，如ArrayList、linkedlist等。不清楚的可以看下上篇文章www.jianshu.com/p/6227ab5b3… 但是向ArrayList这些会出现线程不安全的问题，我们该怎样解决呢？接下来就是要介绍我们线程安全的list集合synchronizedList和CopyOnWriteArrayList。

一、synchronizedList

synchronizedList的使用方式：

public void test(){ArrayList<String> list = new ArrayList<>();List<String> sycList = Collections.synchronizedList(list);sycList.add("a");sycList.remove("a");}
复制代码

从上面的使用方式中我们可以看出，synchronizedList是将List集合作为参数来创建的synchronizedList集合。

synchronizedList为什么是线程安全的呢？ 我们先来看一下他的源码：

        @Overridepublic int size() {synchronized(mutex) {return backingList.size();}}@Overridepublic boolean isEmpty() {synchronized(mutex) {return backingList.isEmpty();}}@Overridepublic Object[] toArray() {synchronized(mutex)  {return backingList.toArray();}}@Overridepublic boolean add(T e) {synchronized(mutex) {return backingList.add(e);}}@Overridepublic boolean remove(Object o) {synchronized(mutex) {return backingList.remove(o);}}
复制代码

我们大概贴了一些常用方法的源码，从上面的源码中我们可以看出，其实synchronizedList线程安全的原因是因为它几乎在每个方法中都使用了synchronized同步锁。

synchronizedList遍历为什么还需要加锁？

synchronizedList官方文档中给出的使用方式是以下方式：

List list = Collections.synchronizedList(new ArrayList());...synchronized (list) {Iterator i = list.iterator(); // Must be in synchronized blockwhile (i.hasNext())foo(i.next());}
复制代码

在以上源码中我们可以看出，官方文档是建议我们在遍历的时候加锁处理的。但是既然内部方法以及加了锁，为什么在遍历的时候还需要加锁呢？我们来看一下它的遍历方法：

        @Overridepublic Iterator<T> iterator() {return backingList.iterator();}
复制代码

从以上源码可以看出，虽然内部方法中大部分都已经加了锁，但是iterator方法却没有加锁处理。那么如果我们在遍历的时候不加锁会导致什么问题呢？ 试想我们在遍历的时候，不加锁的情况下，如果此时有其他线程对此集合进行add或者remove操作，那么这个时候就会导致数据丢失或者是脏数据的问题，所以如果我们对数据的要求较高，想要避免这方面问题的话，在遍历的时候也需要加锁进行处理。 但是既然是使用synchronized加锁进行处理的，那肯定避免不了一些锁开销。有没有效率更好的方式呢？那就是我们另一个主要的并发集合CopyOnWriteArrayList。

二、CopyOnWriteArrayList

CopyOnWriteArrayList是在执行修改操作时，copy一份新的数组进行相关的操作，在执行完修改操作后将原来集合指向新的集合来完成修改操作。具体源码如下：

    /** The array, accessed only via getArray/setArray. */  private volatile transient Object[] array;//保证了线程的可见性  public void add(int index, E element) {final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;if (index > len || index < 0)throw new IndexOutOfBoundsException("Index: "+index+", Size: "+len);Object[] newElements;int numMoved = len - index;if (numMoved == 0)newElements = Arrays.copyOf(elements, len + 1);  //copy一份比当前数组长度+1的array数组else {newElements = new Object[len + 1];         //将add的参数赋值System.arraycopy(elements, 0, newElements, 0, index);System.arraycopy(elements, index, newElements, index + 1,numMoved);}newElements[index] = element;setArray(newElements);           //将原数组指向新的数组} finally {lock.unlock();}}public E remove(int index) {final ReentrantLock lock = this.lock;lock.lock();try {Object[] elements = getArray();int len = elements.length;E oldValue = get(elements, index);int numMoved = len - index - 1;    if (numMoved == 0)setArray(Arrays.copyOf(elements, len - 1));    //copy一份比当前数组长度-1的array数组else {Object[] newElements = new Object[len - 1];System.arraycopy(elements, 0, newElements, 0, index);System.arraycopy(elements, index + 1, newElements, index,numMoved);setArray(newElements);      //将原数组指向新的数组}return oldValue;} finally {lock.unlock();}}/*** 将原数组指向新的数组*/final void setArray(Object[] a) {array = a;}复制代码

从以上源码我们可以看出，它在执行add方法和remove方法的时候，分别创建了一个当前数组长度+1和-1的数组，将数据copy到新数组中，然后执行修改操作。修改完之后调用setArray方法来指向新的数组。在整个过程中是使用ReentrantLock可重入锁来保证不会有多个线程同时copy一个新的数组，从而造成的混乱。并且使用volatile修饰数组来保证修改后的可见性。读写操作互不影响，所以在整个过程中整个效率是非常高的。

总结

synchronizedList适合对数据要求较高的情况，但是因为读写全都加锁，所有效率较低。 CopyOnWriteArrayList效率较高，适合读多写少的场景，因为在读的时候读的是旧集合，所以它的实时性不高。