CopyOnWriteArrayList源码解析

ArrayList

• ArrayList基于数组方式实现，无容量的限制（会扩容）
• 添加元素时可能要扩容（所以最好预判一下），删除元素时不会减少容量（若希望减少容量，trimToSize()），删除元素时，将删除掉的位置元素置为null，下次gc就会回收这些元素所占的内存空间。
• 线程不安全
• add(int index, E element)：添加元素到数组中指定位置的时候，需要将该位置及其后边所有的元素都整块向后复制一位
• get(int index)：获取指定位置上的元素时，可以通过索引直接获取（O(1)）
• remove(Object o)需要遍历数组
• remove(int index)不需要遍历数组，只需判断index是否符合条件即可，效率比remove(Object o)高
• contains(E)需要遍历数组

CopyOnWrite

1、创建：CopyOnWriteArrayList()

• List list = new CopyOnWriteArrayList(); 获取空数组

 private transient volatile Object[] array; //定义一个数组

     /**
     * 获取队列数组
     */
    final Object[] getArray() {
        return array;
    }

    /**
     * 设置数组为a
     */
    final void setArray(Object[] a) {
        array = a;
    }

    /**
     * 创建一个容量为0的数组.
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

• List list2 = new CopyOnWriteArrayList(list1);

    /**
     * 创建包含指定集合的元素的列表，按集合的迭代器返回元素的顺序排列。
     *
     * @param c 集合
     * @throws 如果集合c为null会抛出NullPointerException
     */
    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements; //定义一个数组
        // 如果入参c的类型是CopyOnWriteArrayList，直接获取其数组对象
        if (c.getClass() == CopyOnWriteArrayList.class)
            elements = ((CopyOnWriteArrayList<?>)c).getArray();
        //否则调用 c.toArray()获取数组
        else {
            elements = c.toArray();
            // c.toArray 有可能无法返回 Object[]
            if (elements.getClass() != Object[].class)
                elements = Arrays.copyOf(elements, elements.length, Object[].class); //将其转换为数组
        }
        setArray(elements); //设置数组
    }

• List list3 = new CopyOnWriteArrayList(a);

/**
     * 创建一个包含指定数组a的list。
     *
     * @param 数组a
     * @throws 如果集合c为null会抛出NullPointerException
     */
    public CopyOnWriteArrayList(E[] toCopyIn) {
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class)); //讲数组转换为object类型赋值给array
    }

2、添加元素

• list.add(“hello”);

/**
     * 在队列最后添加指定元素。
     *
     * @param e 
     * @return true/flase
     */
    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); //复制出一个新数组，长度+1
            newElements[len] = e; //新数组添加元素e
            setArray(newElements); //将新数组赋值给array
            return true;
        } finally {
            lock.unlock();
        }
    }

• list.add(1,“hello”);

     /**
     * 在指定位置新增元素。
     *
     * @throws IndexOutOfBoundsException
     */
    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();
        }
    }

• list.addAll©

/**
     * 按指定集合的迭代器返回的顺序，将指定集合中的所有元素追加到此列表的末尾。
     *
     * @param 集合c
     * @return 
     * @throws NullPointerException if the specified collection is null
     * @see #add(Object)
     */
    public boolean addAll(Collection<? extends E> c) {
        Object[] cs = (c.getClass() == CopyOnWriteArrayList.class) ?
            ((CopyOnWriteArrayList<?>)c).getArray() : c.toArray();
        if (cs.length == 0)
            return false;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len == 0 && cs.getClass() == Object[].class)
                setArray(cs);
            else {
                Object[] newElements = Arrays.copyOf(elements, len + cs.length);
                System.arraycopy(cs, 0, newElements, len, cs.length);
                setArray(newElements);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

• list.addAll(3,c)

     /**
     * 将指定集合中的所有元素插入其中列表，从指定位置开始。变化的元素当前位于该位置(如果有的话)和任何后续元素到右派(增加他们的指数)。新元素将出现方法返回它们的顺序指定集合的迭代器。
     *
     * @param 插入的第一个元素的位置
     * @param 集合
     * @return {@code true} if this list changed as a result of the call
     * @throws IndexOutOfBoundsException {@inheritDoc}
     * @throws NullPointerException if the specified collection is null
     * @see #add(int,Object)
     */
    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);
            if (cs.length == 0)
                return false;
            int numMoved = len - index;
            Object[] newElements;
            if (numMoved == 0)
                newElements = Arrays.copyOf(elements, len + cs.length);
            else {
                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、获取元素

• list.get(0)

/**
     * {@inheritDoc}
     * COW保证读的时候不需要加锁
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public E get(int index) {
        return get(getArray(), index);
    }

4、删除元素

• list.remove(0)

 /**
     * 移除列表中指定位置的元素。将任何后续元素向左移动(从它们的索引中减去一个)。返回从列表中删除的元素。
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    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); //将新数组复制给array
            }
            return oldValue;
        } finally {
            lock.unlock(); //解锁
        }
    }

• list.remove(“hello”)

/**
     * 从列表中删除指定元素的第一个出现项。
     *
     * @param 待删除元素
     * @return {@code true} if this list contained the specified element
     */
    public boolean remove(Object o) {
        Object[] snapshot = getArray();
        int index = indexOf(o, snapshot, 0, snapshot.length);
        return (index < 0) ? false : remove(o, snapshot, index);
    }

 /**
     * A version of remove(Object) using the strong hint that given
     * recent snapshot contains o at the given index.
     */
    private boolean remove(Object o, Object[] snapshot, int index) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] current = getArray();
            int len = current.length;
            if (snapshot != current) findIndex: {
                int prefix = Math.min(index, len);
                for (int i = 0; i < prefix; i++) {
                    if (current[i] != snapshot[i] && eq(o, current[i])) {
                        index = i;
                        break findIndex;
                    }
                }
                if (index >= len)
                    return false;
                if (current[index] == o)
                    break findIndex;
                index = indexOf(o, current, index, len);
                if (index < 0)
                    return false;
            }
            Object[] newElements = new Object[len - 1];
            System.arraycopy(current, 0, newElements, 0, index);
            System.arraycopy(current, index + 1,
                             newElements, index,
                             len - index - 1);
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

• list.removeAll©

    /**
     * Removes from this list all of its elements that are contained in
     * the specified collection. This is a particularly expensive operation
     * in this class because of the need for an internal temporary array.
     *
     * @param c collection containing elements to be removed from this list
     * @return {@code true} if this list changed as a result of the call
     * @throws ClassCastException if the class of an element of this list
     *         is incompatible with the specified collection
     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
     * @throws NullPointerException if this list contains a null element and the
     *         specified collection does not permit null elements
     *         (<a href="../Collection.html#optional-restrictions">optional</a>),
     *         or if the specified collection is null
     * @see #remove(Object)
     */
    public boolean removeAll(Collection<?> c) {
        if (c == null) throw new NullPointerException();
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            if (len != 0) {
                // temp array holds those elements we know we want to keep
                int newlen = 0;
                Object[] temp = new Object[len];
                for (int i = 0; i < len; ++i) {
                    Object element = elements[i];
                    if (!c.contains(element))
                        temp[newlen++] = element;
                }
                if (newlen != len) {
                    setArray(Arrays.copyOf(temp, newlen));
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

5、迭代器

   /**
     * Returns an iterator over the elements in this list in proper sequence.
     *
     * <p>The returned iterator provides a snapshot of the state of the list
     * when the iterator was constructed. No synchronization is needed while
     * traversing the iterator. The iterator does <em>NOT</em> support the
     * {@code remove} method.
     *
     * @return an iterator over the elements in this list in proper sequence
     */
    public Iterator<E> iterator() {
        return new COWIterator<E>(getArray(), 0);
    }

/**
     * {@inheritDoc}
     *
     * <p>The returned iterator provides a snapshot of the state of the list
     * when the iterator was constructed. No synchronization is needed while
     * traversing the iterator. The iterator does <em>NOT</em> support the
     * {@code remove}, {@code set} or {@code add} methods.
     */
    public ListIterator<E> listIterator() {
        return new COWIterator<E>(getArray(), 0);
    }

 /**
     * {@inheritDoc}
     *
     * <p>The returned iterator provides a snapshot of the state of the list
     * when the iterator was constructed. No synchronization is needed while
     * traversing the iterator. The iterator does <em>NOT</em> support the
     * {@code remove}, {@code set} or {@code add} methods.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public ListIterator<E> listIterator(int index) {
        Object[] elements = getArray();
        int len = elements.length;
        if (index < 0 || index > len)
            throw new IndexOutOfBoundsException("Index: "+index);

        return new COWIterator<E>(elements, index);
    }

6、其他

• list.set(1,“world”)

/**
     * Replaces the element at the specified position in this list with the
     * specified element.
     *
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    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();
        }
    }