一、CopyOnWriteArrayList

在Java的并发包的并发List中只有CopyOnWriteArrayList。

CopyOnWriteArrayList是一个线程安全的ArrayList,对其进行的修改操作都是在底层的一个复制的数组（快照）上进行的，也就是使用了写时复制策略实现的。

通过查看CopyOnWriteArrayList的源码可以看出，每个CopyOnWriteArrayList对象里面有一个array数组对象用来存放具体元素，其中含有一个ReentrantLock独占锁对象用来保证同时只有一个线程对array的修改。

/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;

CopyOnWriteArrayList会在内部创建一个大小为0的Object数组作为array的初始值，其源码如下：

public CopyOnWriteArrayList() {
        setArray(new Object[0]);
}

CopyOnWriteArrayList的有参构造函数源码如下：

 //这个构造函数接收一个集合元素，它会将集合里面的元组复制到本list中
 public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        setArray(elements);
 }

 //这个构造函数用于创建一个list，其内部元素是入参toCopyIn的副本。   
 public CopyOnWriteArrayList(E[] toCopyIn) {
         setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
 }

二、向CopyOnWriteArrayList中添加元素               

CopyOnWriteArrayList中用来添加元素的函数有add(E e), add(int index, E element), addIfAbsent(E e)和addAllAbsent(Collection<? extends E> e)等，其原理类似。

add(E w)函数的源码如下：

public boolean add(E e) {
        //获取独占锁
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lock();
        try {
            //获取array
            Object[] elements = getArray();
            //获取数组长度
            int len = elements.length;
            //复制array到新数组，添加元素到新数组
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            //使用新数组替换添加前的数组
            setArray(newElements);
            return true;
        } finally {
            //释放独占锁
            lock.unlock();
        }
}

在多线程情况下，如果多个线程同时去调用CopyOnWriteArrayList的add(E e)方法时，只有一个线程会获取到锁，其他线程会被阻塞挂起直到独占锁被释放。

当线程获取到锁之后，就可以保证在该线程添加元素的过程中其他线程不会对array进行操作。

在执行代码Object[] newElements = Arrays.copyOf(elements, len + 1);复制array到一个新数组时，新数组的大小是原来数组大小加1，从这里我们可以知道CopyOnWriteArrayList是一个无界list。

add(E e)方法内部使用加锁机制，所以整个add过程是个原子性操作。值得注意的是，在添加元素时，首先复制了一个快照，然后在快照上进行添加，而不是在原来数组上进行的。

三、从CopyOnWriteArrayList中获取指定位置的元素     

要从CopyOnWriteArrayList中获取指定位置的元素，我们可以使用它的 E get(int index)来获取下标为index的元素，如果元素不存在则抛出IndexOutOfBoundsException异常。其源码如下：

//该方法是通过下标来获取元素
public E get(int index) {
    return get(getArray(), index);
}

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

//该方法是首先获取array数组，然后通过下标访问指定位置的元素
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
   return (E) a[index];
}

四、修改CopyOnWriteArrayList指定位置的元素     

要修改CopyOnWriteArrayList指定位置的元素，可以使用CopyOnWriteArrayList中的E set(int index, E element)方法来修改list指定元素的值，如果指定位置的元素不存在，则抛出IndexOutOfBoundsException异常。其源码如下：

//修改指定下标为index的元素的值为element
 public E set(int index, E element) {
        //获取独占锁，以保证其他线程对array数组进行修改
        final ReentrantLock lock = this.lock;
        //加锁
        lock.lock();
        try {
            //获取当前数组
            Object[] elements = getArray();
            //获取数组指定下标的旧值
            E oldValue = get(elements, index);
            //如果指定位置的元素值与新值不相等则创建新数组并复制元素
            if (oldValue != element) {
                //获取数组的长度
                int len = elements.length;
                //在新数组上修改指定位置的元素值并设置新数组到array
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                //如果指定位置的元素值与新值相等，为了保证volatile的内存语义，还需要重新设置array
                setArray(elements);
            }
            return oldValue;
        } finally {
            //释放锁
            lock.unlock();
        }
 }

五、删除CopyOnWriteArrayList中的元素           

要删除CopyOnWriteArrayList中的元素，可以使用E remove(int index)、boolean remove(Object o)和boolean remove(Object 0, Object[] snapshot, int index)等方法实现，它们的原理相似。

E remove(int index)方法的源码如下：

public E remove(int index) {
    //获取独占锁，以保证删除数据期间其他线程不能对array进行修改
    final ReentrantLock lock = this.lock;
    //加锁
    lock.lock();
    try {
        //获取当前数组
        Object[] elements = getArray();
        //获取数组长度
        int len = elements.length;
        //根据下标index获取数组指定元素
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        //如果要删除的是最后一个元素
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        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();
    }
}

六、遍历CopyOnWriteArrayList

System.out.println("for循环遍历列表：");
int len = arrayList.size();
for(int i = 0; i< len; i++ ){
    System.out.println(arrayList.get(i));
}

//使用迭代器遍历
System.out.println("迭代器遍历列表：");
Iterator<String> itr = arrayList.iterator();
while (itr.hasNext()){   //hasNext()方法用于判断列表中是否还有元素
    System.out.println(itr.next());   //next()方法则具体返回元素
}

示例代码1如下：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @ClassName: CopyOnWriteArrayListDemo
 * @Description:  CopyOnWriteArrayList用法
 * @Author: liuhefei
 * @Date: 2019/12/22
 * @blog: https://www.imooc.com/u/1323320/articles
 **/
public class CopyOnWriteArrayListDemo {

    public static void main(String[] args) {
        CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();
        //添加元素
        arrayList.add("北京");
        arrayList.add("上海");
        arrayList.add("深圳");
        arrayList.add("昆明");
        arrayList.add("天津");
        arrayList.add("银川");
        arrayList.add("兰州");
        arrayList.add("成都");
        System.out.println("arrayList = " + arrayList);

        //CopyOnWriteArrayList是一个无界list。
        //修改指定位置的元素
        arrayList.set(4, "广州");   //注意这里的下标index不能超出列表的长度，否则报错
        arrayList.set(5, "武汉");
        System.out.println("newArrayList = " + arrayList);

        //获取指定位置的元素
        String city = arrayList.get(4);
        System.out.println("city = " + city);

        //删除指定位置的元素
        String deleteCity = arrayList.remove(4);
        System.out.println("deleteCity = " + deleteCity);
        System.out.println("arrayList = " + arrayList);

        //遍历arrayList
        System.out.println("for循环遍历列表：");
        int len = arrayList.size();
        for(int i = 0; i< len; i++ ){
            System.out.println(arrayList.get(i));
        }

        //使用迭代器遍历
        System.out.println("迭代器遍历列表：");
        Iterator<String> itr = arrayList.iterator();
        while (itr.hasNext()){   //hasNext()方法用于判断列表中是否还有元素
            System.out.println(itr.next());   //next()方法则具体返回元素
        }

    }
}

示例代码2如下：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * @ClassName: CopyOnWriteArrayListDemo1
 * @Description: CopyOnWriteArrayList用法
 * 主线程在子线程执行完毕后使用获取的迭代器遍历数组元素，从运行的结果来看，在子线程中进行的操作一个都没有生效，这就是迭代器弱一致性的体现，
 * 需要注意的是：获取迭代器的操作必须在子线程操作之前进行
 * @Author: liuhefei
 * @Date: 2019/12/22
 * @blog: https://www.imooc.com/u/1323320/articles
 **/
public class CopyOnWriteArrayListDemo1 {

    private static volatile CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        arrayList.add("北京");
        arrayList.add("上海");
        arrayList.add("广州");
        arrayList.add("深圳");
        arrayList.add("武汉");
        arrayList.add("成都");
        arrayList.add("郑州");
        arrayList.add("长沙");

        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                //修改list中下标为4的元素为 昆明
                arrayList.set(4, "昆明");
                //删除元素
                arrayList.remove(5);
                arrayList.remove(6);
            }
        });

        //保证在修改线程启动前获取迭代器
        Iterator<String> itr = arrayList.iterator();

        //启动线程
        thread.start();

        //等待子线程执行完毕
        thread.join();

        //迭代元素
        while (itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}