// 鎖
final transient ReentrantLock lock = new ReentrantLock();
// 空數(shù)組
private transient volatile Object[] array;

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}
final void setArray(Object[] a) {
    array = a;
}
// 帶參構(gòu)造
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 {
        // 獲取容器數(shù)組
        Object[] elements = getArray();
        // 獲取容器數(shù)組長度
        int len = elements.length;
        // 創(chuàng)建一個長度+1的新數(shù)組 并把之前的數(shù)據(jù)復制到新數(shù)組
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        // 新數(shù)組尾部賦值
        newElements[len] = e;
        // 把新數(shù)組重新賦值給容器數(shù)組
        setArray(newElements);
        return true;
    } finally {
        lock.unlock();
    }
}

public void add(int index, E element) {
      final ReentrantLock lock = this.lock;
      // 加鎖
      lock.lock();
      try {
          // 獲取容器數(shù)組
          Object[] elements = getArray();
          // 獲取容器數(shù)組長度
          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)
              // 如果正好是尾部 則照舊創(chuàng)建并復制
              newElements = Arrays.copyOf(elements, len + 1);
          else {
              // 不是尾部則創(chuàng)建一個長度+1 的新數(shù)組
              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;
          // 把新數(shù)組重新賦值給容器數(shù)組
          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 {
        // 獲取容器數(shù)組
        Object[] elements = getArray();
        // 獲取原本的舊值
        E oldValue = get(elements, index);
        // 對比新值和舊值
        if (oldValue != element) {
            int len = elements.length;
            // 值不一致 則創(chuàng)建個新數(shù)組，把數(shù)據(jù)復制過去
            Object[] newElements = Arrays.copyOf(elements, len);
            // 修改新數(shù)組對應(yīng)下標下的值
            newElements[index] = element;
            // 把新數(shù)組寫回
            setArray(newElements);
        } else {
            // 新值舊值一樣 就不做任何操作 ，把數(shù)組寫回去就好了
            setArray(elements);
        }
        return oldValue;
    } finally {
        lock.unlock();
    }
}

public boolean remove(Object o) {
    // 獲取容器數(shù)組
    Object[] snapshot = getArray();
    // 遍歷查找元素所在的下標索引
    int index = indexOf(o, snapshot, 0, snapshot.length);
    // 根據(jù)索引移除
    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 {
            // 獲取當前最新的容器數(shù)組
            Object[] current = getArray();
            int len = current.length;
            // 判斷傳入的數(shù)組是否與當前數(shù)組相同  如果不相同則需要判斷傳入index下標的有效性
            if (snapshot != current) findIndex: {
                //得到遍歷范圍最小值，這個范圍不一定能找到元素，當元素被后移時
                //注意index是索引，len是數(shù)組大小。
                int prefix = Math.min(index, len);
                for (int i = 0; i < prefix; i++) {
                    //嚴格的判斷。只有當兩個數(shù)組相同索引位置的元素不是同一個元素；
                    //且current索引元素和參數(shù)o 是相等的時候 則重新獲取賦值index 退出分支
                    if (current[i] != snapshot[i] && eq(o, current[i])) {
                        index = i;
                        break findIndex;
                    }
                }
                // 下標已經(jīng)超過或等于長度 則下標已經(jīng)無效了 直接返回
                if (index >= len)
                    return false;
                // 下標依舊有效并且值相等則 退出分支
                if (current[index] == o)
                    break findIndex;
                // 上面都不滿足則重新查找一次下標
                index = indexOf(o, current, index, len);
                // 不存在了則直接返回
                if (index < 0)
                    return false;
            }
            // 經(jīng)過上面一頓操作 已經(jīng)找到了要移除元素的下標了，所以創(chuàng)建個長度-1的新數(shù)組
            Object[] newElements = new Object[len - 1];
            // 雙復制 與之前一樣 ，index后面的元素需要往前移
            System.arraycopy(current, 0, newElements, 0, index);
            System.arraycopy(current, index + 1, newElements, index, len - index - 1);
            // 新數(shù)組賦值給容器數(shù)組
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            // 獲取容器數(shù)組
            Object[] elements = getArray();
            int len = elements.length;
            // 獲取舊值
            E oldValue = get(elements, index);
            int numMoved = len - index - 1;
            if (numMoved == 0)
                // 如果是尾部則直接創(chuàng)建長度-1的數(shù)組再復制過去 
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                // 不是尾部 則雙copy ，index后的數(shù)據(jù)整體前移一位
                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();
        }
    }