CopyOnWriteArrayList源码分析

一、CopyOnWriteArrayList

Copy-On-Write简称COW，是一种用于集合的并发访问的优化策略。

基本思想是：当我们往一个集合容器中写入元素时（添加、修改、删除），并不会直接在集合容器中写入，而是先将当前集合容器进行Copy，复制出一个新的容器，然后新的容器里写入元素，写入操作完成之后，再将原容器的引用指向新的容器。

二、CopyOnWriteArrayList 源码分析

1.CopyOnWriteArrayList构造方法

// 无参构造，初始化一个Object数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }
 
	// 有参构造，参数为Collection子类
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
		// 初始化类型是CopyOnWriteArrayList
        if (c.getClass() == CopyOnWriteArrayList.class)
			// 获取参数的Array数组对象，存入
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
			// 初始化类型不是是CopyOnWriteArrayList，将集合转换为数组
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
			// elements不是	Object[]，将elements数组复制到一个Object数组中
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
		// 存入
        setArray(elements);
    }

2、add()方法

添加新的元素

 // 添加新元素
    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 {
				// 不是最后一个元素
                newElements = new Object[len + 1];
				// 复制下标元素之前的元素
                System.arraycopy(elements, 0, newElements, 0, index);
				// 复制下标元素之后的元素
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
			// 指定位置添加元素
            newElements[index] = element;
			// 调用setArray方法将新数组存到array数组
            setArray(newElements);
        } finally {
			// 释放锁
            lock.unlock();
        }
    }

 添加一个集合到指定位置

//添加一个集合到指定位置
    public boolean addAll(int index, Collection<? extends E> c) {
		// 将集合转换为数组
        Object[] cs = c.toArray();
        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);
			// 传入集合大小为0
            if (cs.length == 0)
                return false;
            int numMoved = len - index;
            Object[] newElements;
			// 指定下标在末尾，copy至末尾
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + cs.length);
            else {
				// 创建一个长度len + cs.length的数组
                newElements = new Object[len + cs.length];
				// 复制下标元素之前的元素
                System.arraycopy(elements, 0, newElements, 0, index);
				// 复制下标元素之后的元素
                System.arraycopy(elements, index,
                                 newElements, index + cs.length,
                                 numMoved);
            }
			// 将集合复制到指定位置
            System.arraycopy(cs, 0, newElements, index, cs.length);
			// 存入
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

3、set()方法

修改指定范围的值

// 修改
    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 {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
			// 返回旧数组
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

 4、remove()

删除指定下标元素

// 删除指定下标元素
    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();
        }
    }

删除指定长度的元素 

// 删除指定长度的元素
    void removeRange(int fromIndex, int toIndex) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
			// 获取旧数组
            Object[] elements = getArray();
            int len = elements.length;
 
            // 下标越界
            if (fromIndex < 0 || toIndex > len || toIndex < fromIndex)
                throw new IndexOutOfBoundsException();
            int newlen = len - (toIndex - fromIndex);
            int numMoved = len - toIndex;
			// 判断删除位置为后半段
            if (numMoved == 0)
				// 复制前半段元素
                setArray(Arrays.copyOf(elements, newlen));
            else {
				// 创建一个新数组
                Object[] newElements = new Object[newlen];
				// 复制删除范围前的元素
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
				// 复制删除范围后的元素
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
				// 存入
                setArray(newElements);
            }
        } finally {
            lock.unlock();
        }
    }

三、CopyOnWriteArrayList优点

实现对CopyOnWrite集合容器写入操作时的线程安全，但同时并不影响进行并发的读取操作。所以CopyOnWrite容器也是一种读写分离的思想。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发集合容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。