Copy-On-Write读写分离策略和CopyOnWriteArrayList源码分析

落日映苍穹つ 2022-05-14 02:25 146阅读 0赞

> Copy-On-Write简称COW，是一种用于程序设计的优化策略。JDK有两种Copy-On-Write容器，CopyOnWriteArrayList和CopyOnWriteArraySet。

> Copy-On-Write容器，就是写时复制容器。支持并发的读，如果是写操作，那么会创建一个新的容器，在新的容器中完成写操作，在这个过程中，读操作依然读的是旧容器中的值。完成写操作之后，还会把新容器的引用指向原有容器的引用。这样做的好处就是，可以支持并发的读，而不需要加锁，因为当前容器不会添加或者删除元素。所以Copy-On-Write容器是一种读写分离容器，体现了读写分离的思想。

CopyOnWriteArrayList源码分析：

private volatile transient Object[] array;
     final Object[] getArray() {
            return array;
     }
    final void setArray(Object[] a) {
            array = a;
    }

将array设置为私有的，只能通过本类的get和set方法操作array。

*  更新操作

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

CopyOnWriteArrayList的支持在某个索引处设置值，从源码中可以看到，因为这是写操作，所以加了锁。先从原容器中获取到index处的旧值，然后比较新值和旧值是否相同，如果相同的话，直接调用setArray方法，原容器保持不变；如果不相同，就会创建一个新的容器，在新容器中作写操作。

*  添加操作

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();
            }
        }
    
    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 {
                    newElements = new Object[len + 1];
                    System.arraycopy(elements, 0, newElements, 0, index);
                    System.arraycopy(elements, index, newElements, index + 1,
                                     numMoved);
                }
                newElements[index] = element;
                setArray(newElements);
            } finally {
                lock.unlock();
            }
        }

添加方法有两个，第一个是直接在容器的最后添加；后一个是在指定位置添加元素，这就需要判断元素的位置，然后判断需要移动元素的个数，如果需要移动元素个数为0，意味着也是直接在元素的最后添加元素，等同于第一个方法；反之，需要扩容容器，然后分两次copy原容器的元素，第一次是0到index，第二次是index+1到最后，最后设置index处的值，然后调用setArray方法，设置新容器。

*  删除操作

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();
            }
        }
    
    public boolean remove(Object o) {
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                Object[] elements = getArray();
                int len = elements.length;
                if (len != 0) {
                    int newlen = len - 1;
                    Object[] newElements = new Object[newlen];
    
                    for (int i = 0; i < newlen; ++i) {
                        if (eq(o, elements[i])) {
                        //o和每一个元素比较，如果相等的话，进入循环
                            for (int k = i + 1; k < len; ++k)
                                newElements[k-1] = elements[k];//复制后面的元素
                            setArray(newElements);
                            return true;
                        } else
                            newElements[i] = elements[i];
                    }
                    if (eq(o, elements[newlen])) {
                        setArray(newElements);
                        return true;
                    }
                }
                return false;
            } finally {
                lock.unlock();
            }
        }

删除操作也有两个方法，第一个是删除指定位置的元素；第二个是删除第一次出现的指定的元素，如果存在的话。

CopyOnWriteArrayList还有其他许多方法，就不一一列举了，但是，都有一个特点：如果是读操作，并发不加锁；如果是写操作，加锁。如果在读操作的过程中，发生了写操作，那么会创建一个新的容器，在新容器中做写操作，在写操作完成之前，读的都是以旧容器的值。