java集合之CopyOnWriteArrayList

╰半橙微兮° 2022-05-09 02:10 168阅读 0赞

### CopyOnWriteArrayList ###

CopyOnWriteArrayList是juc中提供的并发安全的ArrayList，我们拆分一下类名"Copy"“On”“Write”“ArrayList”，从字面意思我们推断出，这个是以在Write时进行Copy数组元素的ArrayList；

它主要具有一下特性：

*  它是线程安全的；
 *  允许元素为null；
 *  支持随机访问、浅拷贝，可序列化；
 *  迭代器使用快照方式，且在迭代期间数组不会改变，故不会出现并发异常；
 *  可变操作（set，add，remove，clear，replace，sort，sublist等等）的开销很大，因为通常需要复制整个基础数组；
 *  所有的get方法只是获取数组对应下标上的元素(无需加锁控制)

CopyOnWriteArrayList使用了一种叫写时复制的方法，当有新元素添加到CopyOnWriteArrayList时，先将原有数组的元素拷贝到新数组中，然后在新的数组中做写操作，写完之后，再将原来的数组引用（volatile修饰的数组引用）指向新数组；

CopyOnWriteArrayList提供了弱一致性的迭代器，保证在获取迭代器后，其他线程对list的修改该不可见，迭代器遍历时候的数组是获取迭代器时候的一个快照；

CopyOnWriteArrayList是使用空间换时间的方式进行工作，它主要适用于读多些少，并且数据内容变化比较少的场景(最好初始化时就进行加载数据到CopyOnWriteArrayList中)；

*  **add(E e)**：添加元素

public boolean add(E e) {
    /**
    * 增加元素 e 到数组的末尾
    * 操作步骤:
    * 1. 获取全局的 reentrantLock
    * 2. 将原来的 array1 copy 到一个 array.length + 1 的数组 array2 里面
    * 3. 将 先添加的元素e添加到新数组 array2 的最后一个空间里面 (array2[array2.length - 1] = e)
    * 4. 将 新数组 array2 赋值给 CopyOnWriteArrayList 中的 array
    */
    final ReentrantLock lock = this.lock;
    lock.lock(); // 1. 获取 全局 lock
    try{
    Object[] elements = getArray(); // 2. 获取原来的数组
    int len = elements.length;
    Object[] newElements = Arrays.copyOf(elements, len + 1); // 3. 新建一个 array2 将原来的数据赋值到这个新建的数组里面
    newElements[len] = e; // 4. 将 e 赋值给 array2的最后一个空间里面
    setArray(newElements); // 5. 将新数组 array2 赋值给 CopyOnWriteArrayList 中的 array
    return true;
    }finally {
    lock.unlock(); // 6. 释放锁
    }
    
    }

*  \*\*add(int index, E element)：\*\*添加元素到指定位置

public void add(int index, E element) {
    /**
    * 将元素 e 插入到数组 指定的索引下标 index 下
    * 操作步骤:
    * 1. 获取全局的锁
    * 2. 获取 CopyOnWriteArrayList 的 array, 及 array.length
    * 3. 进行参数校验 (index > len || index < 0) 则直接抛异常 -> 说明元素的插入只能在 0 - array.length 之间(包含两个端点)
    * 4. 获取插入点 index 与 array.length 之间的步长, 进行分类讨论
    * 1) 插入的数据正好在 原array数组的后一个节点 (numMoved = len), 则直接新建一个 array, 将原来的 array copy 过来
    * 2) 插入的 index 满足 0 <= index <= len - 1, 则新建一个数组, 原来 o -> index(index不包含) 拷贝来, index后面的数据拷贝到新数组的 index + 1 的空间
    * 5. 将 e 设置到 新 array 的 index 位置
    * 6. 将 新 array 设置到 CopyOnWriteArrayList 里面
    */
    final ReentrantLock lock = this.lock;
    lock.lock(); // 1. 获取全局的锁
    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){ // 走到这一步, 说明数据是插入到oldArray.length(这个值是指下标) 位置上的元素
    newElements = Arrays.copyOf(elements, len + 1); // 直接拷贝原数组到一个新的 array 数组中, 这个数组的长度是 len + 1
    }else{
    newElements = new Object[len + 1];
    System.arraycopy(elements, 0, newElements, 0, index); // 将原数组 index 前的数组都拷贝到新的数组里面
    System.arraycopy(elements, index, newElements, index + 1, numMoved); // 将原数组 index 以后的元素都 copy到新的数组里面(包括index位置的元素)
    }
    newElements[index] = element; // 将 index 赋值 element
    setArray(newElements); // 将 新的 array set到 CopyOnWriteArrayList 上
    }finally {
    lock.unlock();
    }
    }

*  \*\*remove(int index)：\*\*删除指定位置元素

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){ // 说明删除的元素的位置在 len - 1 上, 直接拷贝原数组的前 len - 1 个元素
    setArray(Arrays.copyOf(elements, len - 1));
    }else{
    Object[] newElements = new Object[len - 1];
    System.arraycopy(elements, 0, newElements, 0, index); // 拷贝原数组 0 - index之间的元素 (index 不拷贝)
    System.arraycopy(elements, index + 1, newElements, index, numMoved); // 拷贝原数组 index+1 到末尾之间的元素 (index＋1也进行拷贝)
    setArray(newElements);
    }
    }finally {
    lock.unlock();
    }
    return null;