《CopyOnWriteArrayList核心源码阅读》

public class CopyOnWriteArrayList
    implements List, RandomAccess, Cloneable, java.io.Serializable {
    
    //定义ReentrantLock类型的锁	
    final transient ReentrantLock lock = new ReentrantLock();

    //CopyOnWriteArrayList内部实际维护一个Object类型数组，数组里是存放的内容
    private transient volatile Object[] array;

    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    //返回数组array	
    final Object[] getArray() {
        return array;
    }

    /**
     * Sets the array.
     */
    //改变数组指向，将array指向数组a
    final void setArray(Object[] a) {
        array = a;
    }

    //无参构造函数，将数组array初始化为空数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    //get（）方法，获取数组下标为index的内容
    @SuppressWarnings("unchecked")
    private E get(Object[] a, int index) {
        return (E) a[index];
    }

    //方法重载，调用了get(Object[] a, int index)
    public E get(int index) {
        return get(getArray(), index);
    }

    //改变下标为index的内容为element
    public E set(int index, E element) {
        final ReentrantLock lock = this.lock;//定义局部变量,得到ReenTrantLock锁对象
        lock.lock();//获得锁
        try {
            Object[] elements = getArray();//得到原数组
            E oldValue = get(elements, index);//得到下标为index的内容

            if (oldValue != element) {//如果原内容与要设置的内容不同
                int len = elements.length; //得到原数组长度
                Object[] newElements = Arrays.copyOf(elements, len);//复制原数组，得到新数组，长度为len
                newElements[index] = element;//将新数组index下标位置内容改为element
                setArray(newElements);//将内部维护的数组改为新数组
            } else {//如果原内容与要设置的内容相同
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);//将得到的数组重新设置（不变）
            }
            return oldValue;//将原下标内容返回
        } finally {
            lock.unlock();//释放锁
		//将内容都写在try块，释放锁在finally，即使发生异常，也会释放锁
        }
    }

    //添加内容
    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);//复制原数组，得到新数组，长度为len+1
            newElements[len] = e;//将新数组len下标位置内容设为e
            setArray(newElements);//将内部维护的数组改为新数组
            return true;//添加成功，返回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)//如果指定位置>原数组长度或者指定位置<0，抛出异常
                throw new IndexOutOfBoundsException("Index: "+index+                                    ", Size: "+len);
	    //如果指定位置合理
            Object[] newElements;//定义新数组
            int numMoved = len - index;//要移动的元素个数
            if (numMoved == 0)//如果为0
                newElements = Arrays.copyOf(elements, len + 1);//复制原数组，长度为len+1
            else {//如果不为0
                newElements = new Object[len + 1];//初始化新数组，长度为len+1
                System.arraycopy(elements, 0, newElements, 0, index);//将原数组从0开始，新数组从0开始，复制长度为index
                System.arraycopy(elements, index, newElements, index + 1,
                                 numMoved);//原数组从index开始，新数组从index+1开始,复制长度为numMoved
            }
            newElements[index] = element;//将index位置内容设为element
            setArray(newElements);//将内部维护的数组改为新数组
        } finally {
            lock.unlock();//释放锁
        }
    }
	
    //删除index位置的内容
    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);//得到原数组index下标内容
            int numMoved = len - index - 1;//要移动的元素个数
            if (numMoved == 0)//如果为0
                setArray(Arrays.copyOf(elements, len - 1));//设置数组为新数组，新数组为原数组的复制,复制长度为len-1
            else {//如果不为0
                Object[] newElements = new Object[len - 1];//初始化新数组，长度为len-1
                System.arraycopy(elements, 0, newElements, 0, index);//将原数组从0开始，新数组从0开始，复制长度为index
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);//将原数组从index+1开始（跳过index），新数组从index开始，复制长度为numMoved
                setArray(newElements);//将内部维护的数组改为新数组
            }
            return oldValue;//返回删除内容
        } finally {
            lock.unlock();//释放锁
        }
    }

   //删除下标从fromIndex开始，到toInde(不包括toIndex)结束的内容
    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)
//如果开始位置<0或者终点位置大于0，或者终点位置<开始位置
                throw new IndexOutOfBoundsException();//抛出异常
            int newlen = len - (toIndex - fromIndex);//新数组长度
            int numMoved = len - toIndex;//要移动的元素个数
            if (numMoved == 0)//如果为0
                setArray(Arrays.copyOf(elements, newlen));//复制原数组
            else {//不为0
                Object[] newElements = new Object[newlen];//定义新数组，长度为newlen
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
//原数组从0开始，新数组从0开始，复制长度为fromIndex
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
//原数组从toIndex开始，新数组从fromIndex开始，复制长度为numMoved
                setArray(newElements);//将内部维护的数组改为新数组
            }
        } finally {
            lock.unlock();//解锁
        }
    }

    //从此列表中删除指定集合中包含的所有元素
    public boolean removeAll(Collection c) {
	//如果此列表包含空元素，并且指定的集合不允许空元素（ optional ），或者如果指定的集合为空 
        if (c == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;//得到锁的对象
        lock.lock();//加锁
        try {
            Object[] elements = getArray();//得到原数组
            int len = elements.length;//得到原数组长度
            if (len != 0) {//如果原数组长度不为0
                // temp array holds those elements we know we want to keep
                int newlen = 0;//定义newlen为0
                Object[] temp = new Object[len];//定义数组temp，长度为len
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];//获取原数组下标为i的元素
                    if (!c.contains(element))//如果集合c中不包含element
                        temp[newlen++] = element;//将element添加到数组temp
                }
                if (newlen != len) {//如果newlen不等于len:说明删除成功
                    setArray(Arrays.copyOf(temp, newlen));
//复制数组temp(temp中对的元素是此列表和c列表的差集)，并设为内部维护的数组
                    return true;//删除成功，返回true
                }
            }
            return false;//删除不成功，返回false
        } finally {
            lock.unlock();//关锁
        }
    }


   //从列表中删除所有元素。
    public void clear() {
        final ReentrantLock lock = this.lock;//加锁
        lock.lock();
        try {
            setArray(new Object[0]);//将内部维护的数组设为长度为0的新数组
        } finally {
            lock.unlock();//解锁
        }
    }

   //将指定列表添加至此列表尾部
    public boolean addAll(Collection c) {
        //列表c跟CopyOnWriteArrayList是否是同一类
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
            ((CopyOnWriteArrayList)c).getArray() : c.toArray();
	//是：将数组c转换为CopyOnWriteArrayList类型,并将其内部数组给cs
	//不是：将c转换为数组，交给数组cs
        if (cs.length == 0)//如果cs长度为0
            return false;//返回false
        final ReentrantLock lock = this.lock;//获取锁对象
        lock.lock();//加锁
        try {
            Object[] elements = getArray();//获取内部维护的数组
            int len = elements.length;//获取内部维护的数组长度
	    //如果内部维护的数组长度为0，并且数组cs的类型为Object类型
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);//将内部维护的数组设置为cs
            else { //如果内部维护的数组长度不为0，或者数组cs的类型不为Object类型
		//复制原数组，给数组newElements，数组newElements长度为len+cs.length
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
		//CS数组从0开始，数组newElements从len开始，复制长度为cs.length
                System.arraycopy(cs, 0, newElements, len, cs.length);
		//设置内部维护的数组为newElements
                setArray(newElements);
            }
            return true;//添加成功，返回true
        } finally {
            lock.unlock();//解锁
        }
    }

    //使用提供的 Comparator对此列表进行排序以比较元素。
    public void sort(Comparator c) {
        final ReentrantLock lock = this.lock;//获取锁对象
        lock.lock();//加锁
        try {
            Object[] elements = getArray();//获取内部维护的数组
            Object[] newElements = Arrays.copyOf(elements, elements.length);//复制内部维护的数组
            @SuppressWarnings("unchecked") E[] es = (E[])newElements;
            Arrays.sort(es, c);//调用Arrays.sort()方法，使用提供的 Comparator对此列表进行排序
            setArray(newElements);//将内部维护的数组设置为newElements
        } finally {
            lock.unlock();//解锁
        }
    }

    //将指定的对象与此列表进行比较以获得相等性
    public boolean equals(Object o) {
        if (o == this)//如果地址相等
            return true;
        if (!(o instanceof List))//如果o 不输入List类型的集合
            return false;

        List list = (List)(o);//将o从Object类型转换为List
        Iterator it = list.iterator();//获取迭代器
        Object[] elements = getArray();//获取内部数组
        int len = elements.length;//获取内部数组的长度
        for (int i = 0; i < len; ++i)
		//如果it没有下一位或者（elements[i]与it.next()不相等）
            if (!it.hasNext() || !eq(elements[i], it.next()))
                return false;
	//如果it还有下一位(list长度与内部数组长度不相等)
        if (it.hasNext())
            return false;
        return true;
    }

    //返回此列表的哈希码值
    public int hashCode() {
        int hashCode = 1;
        Object[] elements = getArray();//获取内部数组
        int len = elements.length;//获取数组长度
        for (int i = 0; i < len; ++i) {
            Object obj = elements[i];
            hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());//计算哈希码值
        }
        return hashCode;
    }
}