COW

如果有多个调用者请求相同资源,他们会获得相同的指针指向同一个资源,知道某个调用者试图修改资源内容,系统才会真正复制一份专用副本给调用者,而其他调用者所见到的最初资源不变.

  • 优点:如果不修改,就不会有副本建立
  • 缺点:
    • 内存占用:如果CopyOnWriteArrayList经常要增删改里面的数据，经常要执行add()、set()、remove()的话，那是比较耗费内存的。
      • 因为我们知道每次add()、set()、remove()这些增删改操作都要复制一个数组出来。
    • 数据一致性：CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。
      • 从上面的例子也可以看出来，比如线程A在迭代CopyOnWriteArrayList容器的数据。线程B在线程A迭代的间隙中将CopyOnWriteArrayList部分的数据修改了(已经调用setArray()了)。但是线程A迭代出来的是原有的数据。

CopyOnWriteArrayList

  • 线程安全
  • 底层通过复制数组实现
  • 遍历时候不会抛出ConcurrentModificationException异常
  • 元素可以为null

基本结构

  1.     /** 可重入锁对象 */
  2.     final transient ReentrantLock lock = new ReentrantLock();
  4.     /** CopyOnWriteArrayList底层由数组实现，volatile修饰 */
  5.     private transient volatile Object[] array;
  7.     /**
  8.      * 得到数组
  9.      */
  10.     final Object[] getArray() {
  11.         return array;
  12.     }
  14.     /**
  15.      * 设置数组
  16.      */
  17.     final void setArray(Object[] a) {
  18.         array = a;
  19.     }
  21.     /**
  22.      * 初始化CopyOnWriteArrayList相当于初始化数组
  23.      */
  24.     public CopyOnWriteArrayList() {
  25.         setArray(new Object[0]);
  26.     }

CopyOnWriteArrayList底层就是数组，加锁就交由ReentrantLock来完成。

add

  1.     public boolean add(E e) {
  3.     // 加锁
  4.         final ReentrantLock lock = this.lock;
  5.         lock.lock();
  6.         try {
  8.       // 得到原数组的长度和元素
  9.             Object[] elements = getArray();
  10.             int len = elements.length;
  12.       // 复制出一个新数组
  13.             Object[] newElements = Arrays.copyOf(elements, len + 1);
  15.       // 添加时，将新元素添加到新数组中
  16.             newElements[len] = e;
  18.       // 将volatile Object[] array 的指向替换成新数组
  19.             setArray(newElements);
  20.             return true;
  21.         } finally {
  22.             lock.unlock();
  23.         }
  24.     }
  27. public int size() {
  28.     // 直接得到array数组的长度
  29.     return getArray().length;
  30. }
  32. public E get(int index) {
  33.     return get(getArray(), index);
  34. }
  36. final Object[] getArray() {
  37.     return array;
  38. }
  1. 上锁
  2. 复制一个新的数字
  3. 拷贝
  4. 在末尾加上被添加的元素
  5. 使元素指向新数组
  6. 解锁

set

  1. public E set(int index, E element) {
  2.   final ReentrantLock lock = this.lock;
  3.   lock.lock();
  4.   try {
  6.     // 得到原数组的旧值
  7.     Object[] elements = getArray();
  8.     E oldValue = get(elements, index);
  10.     // 判断新值和旧值是否相等
  11.     if (oldValue != element) {
  13.       // 复制新数组，新值在新数组中完成
  14.       int len = elements.length;
  15.       Object[] newElements = Arrays.copyOf(elements, len);
  16.       newElements[index] = element;
  18.       // 将array引用指向新数组
  19.       setArray(newElements);
  20.     } else {
  21.       // Not quite a no-op; enssures volatile write semantics
  22.       setArray(elements);
  23.     }
  24.     return oldValue;
  25.   } finally {
  26.     lock.unlock();
  27.   }
  28. }
  1. 加锁
  2. 获取index位置的值
  3. 如果值一样,不修改
  4. 值不一样,复制新数组,设置数组指向
  5. 解锁
  6. 返回

遍历

CopyOnWriteArrayList - 图1

  1.   // 1. 返回的迭代器是COWIterator
  2.   public Iterator<E> iterator() {
  3.         return new COWIterator<E>(getArray(), 0);
  4.     }
  7.   // 2. 迭代器的成员属性
  8.     private final Object[] snapshot;
  9.     private int cursor;
  11.   // 3. 迭代器的构造方法
  12.   private COWIterator(Object[] elements, int initialCursor) {
  13.         cursor = initialCursor;
  14.         snapshot = elements;
  15.     }
  17.   // 4. 迭代器的方法...
  18.   public E next() {
  19.         if (! hasNext())
  20.             throw new NoSuchElementException();
  21.         return (E) snapshot[cursor++];
  22.     }
  24.   //.... 可以发现的是，迭代器所有的操作都基于snapshot数组，而snapshot是传递进来的array数组

可以发现的是，迭代器所有的操作都基于snapshot数组，而snapshot是传递进来的array数组
**