CopyOnWriteArrayList

在添加数据的时候是加锁的

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();
    }
}

加锁保证避免在多线程并发add的时候，复制出多个副本出来，导致最终的数组数据不是我们期望的

读数据不需要加锁

public E get(int index) {
    return get(getArray(), index);
}

由于所有的写操作都是在新数组进行的，这个时候如果有线程并发的写，则通过锁来控制，如果有线程并发的读，则分几种情况：

• 1、如果写操作未完成，那么直接读取原数组的数据；

• 2、如果写操作完成，但是引用还未指向新数组，那么也是读取原数组数据；

• 3、如果写操作完成，并且引用已经指向了新的数组，那么直接从新数组中读取数据。

删除操作

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));
         }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的使用场景

通过上面的分析，CopyOnWriteArrayList 有几个缺点：

• 1、由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致young gc或者full gc

• 2、不能用于实时读的场景，像拷贝数组、新增元素都需要时间，所以调用一个set操作后，读取到数据可能还是旧的,虽然CopyOnWriteArrayList 能做到最终一致性,但是还是没法满足实时性要求；

CopyOnWriteArrayList 合适读多写少的场景，不过这类慎用
因为谁也没法保证CopyOnWriteArrayList 到底要放置多少数据，万一数据稍微有点多，每次add/set都要重新复制数组，这个代价实在太高昂了。在高性能的互联网应用中，这种操作分分钟引起故障。

CopyOnWriteArrayList透露的思想

如上面的分析CopyOnWriteArrayList表达的一些思想：

• 1、读写分离，读和写分开
• 2、最终一致性
• 3、使用另外开辟空间的思路，来解决并发冲突