CopyOnWriteArrayList源码分析

成员变量

	//用于存放数据的array
    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;
	
	//锁
	/** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

构造函数

	//无参构造函数
	public CopyOnWriteArrayList() {
		//给array赋值为一个空的object数组
        setArray(new Object[0]);
    }
    //集合类型的参数
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        //如果是CopyOnWriteArrayList，直接调用getArray方法获取到数组，赋值给elements 
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        else {
        	//调用toArray方法，获取到数组赋值给elements 
            elements = c.toArray();
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            //看上面这行注释，toArray方法有可能返回的不是Object[]类型 ， 比如Arrays.asList方法返回的list是Arrays内部类ArrayList，toArray方法返回的是泛型的数组类型。
            //如果返回的不是object类型的数组，调用Arrays.copyOf来将数组复制给elements 
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class);
        }
        //将elements赋值给array
        setArray(elements);
    }
    //数组类型的参数
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

对array的get和set

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

add方法，需要加锁

	//末尾添加数据
	public boolean add(E e) {
        final ReentrantLock lock = this.lock;
        //添加数据需要进行加锁
        lock.lock();
        try {
        	//获取 array 复制给 elements 
            Object[] elements = getArray();
            //获取elements 的长度
            int len = elements.length;
            //将elements 复制到新的数组 ， 新的数组长度为 原来数组长度 +1
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //将新的数组的len位置数组 设置为 e
            newElements[len] = e;
            //将新数组赋值给array
            setArray(newElements);
            return true;
        } finally {
        	//解锁
            lock.unlock();
        }
    }
    //指定位置添加数据
    public void add(int index, E element) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
    		//获取array赋值给elements
            Object[] elements = getArray();
            int len = elements.length;
            //检查index
            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];
                //将 原数组前面index个数据 复制到 新数组中
                System.arraycopy(elements, 0, newElements, 0, index);
                //将 原数组index位置及以后的数据 复制到新数组 index+1位置及以后的位置           
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);
            }
            //将新数组index位置的数据复制为element
            newElements[index] = element;
            //将新数组复制给array
            setArray(newElements);
        } finally {
            lock.unlock();
        }
    }

get方法，直接返回array对应位置的数据，无锁

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

remove方法，需要加锁

	//移除指定下标位置的数据
    public E remove(int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
        	//获取array赋值给elements
            Object[] elements = getArray();
            int len = elements.length;
            //获取index位置的值
            E oldValue = get(elements, index);
            //计算需要前移的数据个数
            int numMoved = len - index - 1;
            //移除的是最后一个数据，直接将原数组数据len-1个数据 复制到新数组 在赋值给array
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
            	//实例化一个新的数组长度为len - 1
                Object[] newElements = new Object[len - 1];
                //将 原数组前面index位置前面的数据 复制到 新数组中
                System.arraycopy(elements, 0, newElements, 0, index);
                //将 原数组index+1位置及后面的的数据 复制到 新数组index位置及以后
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                //将新数组 赋值给 array
                setArray(newElements);
            }
            //返回被移除的值
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

还是很简单的。对数据的添加和删除，会加锁，并且不操作原数组的数据，操作一个新的数组，在用新的数据替换掉原本的数组。