java集合之CopyOnWriteArrayList源码解析

// 锁
final transient ReentrantLock lock = new ReentrantLock();
// 空数组
private transient volatile Object[] array;

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
final void setArray(Object[] a) {
    array = a;
}
// 带参构造
public CopyOnWriteArrayList(E[] toCopyIn) {
    setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

Object[] aa=new Object[]{1,2};
Object[] aa1=aa;
System.out.println("改变前："+aa1[0]);
aa[0]=3;
System.out.println("改变后："+aa1[0]);

public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    // 加锁
    lock.lock();
    try {
        // 获取容器数组
        Object[] elements = getArray();
        // 获取容器数组长度
        int len = elements.length;
        // 创建一个长度+1的新数组 并把之前的数据复制到新数组
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 新数组尾部赋值
        newElements[len] = e;
        // 把新数组重新赋值给容器数组
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

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);
          else {
              // 不是尾部则创建一个长度+1 的新数组
              newElements = new Object[len + 1];
              // 依旧是复制 但这里复制了两次 
              // 0-index的元素复制一次 位置不变
              System.arraycopy(elements, 0, newElements, 0, index);
              // index-尾部的元素复制一次 整体位置都后移一位
              System.arraycopy(elements, index, newElements, index + 1,
                               numMoved);
          }
          // 指定位置赋值
          newElements[index] = element;
          // 把新数组重新赋值给容器数组
          setArray(newElements);
      } finally {
          lock.unlock();
      }
  }

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

public E set(int index, E element) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        // 获取容器数组
        Object[] elements = getArray();
        // 获取原本的旧值
        E oldValue = get(elements, index);
        // 对比新值和旧值
        if (oldValue != element) {
            int len = elements.length;
            // 值不一致 则创建个新数组，把数据复制过去
            Object[] newElements = Arrays.copyOf(elements, len);
            // 修改新数组对应下标下的值
            newElements[index] = element;
            // 把新数组写回
            setArray(newElements);
        } else {
            // 新值旧值一样 就不做任何操作 ，把数组写回去就好了
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

public boolean remove(Object o) {
    // 获取容器数组
    Object[] snapshot = getArray();
    // 遍历查找元素所在的下标索引
    int index = indexOf(o, snapshot, 0, snapshot.length);
    // 根据索引移除
    return (index < 0) ? false : remove(o, snapshot, index);
}
private boolean remove(Object o, Object[] snapshot, int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            // 获取当前最新的容器数组
            Object[] current = getArray();
            int len = current.length;
            // 判断传入的数组是否与当前数组相同  如果不相同则需要判断传入index下标的有效性
            if (snapshot != current) findIndex: {
                //得到遍历范围最小值，这个范围不一定能找到元素，当元素被后移时
                //注意index是索引，len是数组大小。
                int prefix = Math.min(index, len);
                for (int i = 0; i < prefix; i++) {
                    //严格的判断。只有当两个数组相同索引位置的元素不是同一个元素；
                    //且current索引元素和参数o 是相等的时候 则重新获取赋值index 退出分支
                    if (current[i] != snapshot[i] && eq(o, current[i])) {
                        index = i;
                        break findIndex;
                    }
                }
                // 下标已经超过或等于长度 则下标已经无效了 直接返回
                if (index >= len)
                    return false;
                // 下标依旧有效并且值相等则 退出分支
                if (current[index] == o)
                    break findIndex;
                // 上面都不满足则重新查找一次下标
                index = indexOf(o, current, index, len);
                // 不存在了则直接返回
                if (index < 0)
                    return false;
            }
            // 经过上面一顿操作 已经找到了要移除元素的下标了，所以创建个长度-1的新数组
            Object[] newElements = new Object[len - 1];
            // 双复制 与之前一样 ，index后面的元素需要往前移
            System.arraycopy(current, 0, newElements, 0, index);
            System.arraycopy(current, index + 1, newElements, index, len - index - 1);
            // 新数组赋值给容器数组
            setArray(newElements);
            return true;
        } 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)
                // 如果是尾部则直接创建长度-1的数组再复制过去 
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                // 不是尾部 则双copy ，index后的数据整体前移一位
                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();
        }
    }