Java²¢·¢¡ª¡ªCopyOnArrayList

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    private static final long serialVersionUID = 8673264195747942595L;

    /** The lock protecting all mutators */
    final transient ReentrantLock lock = new ReentrantLock();

    /** CopyOnWriteArrayListµ×²ãÓÉÊý×éʵÏÖ£¬volatileÐÞÊΣ¬±£Ö¤Êý×éµÄ¿É¼ûÐÔ */
    private transient volatile Object[] array;

    /**
     * Gets the array.  Non-private so as to also be accessible
     * from CopyOnWriteArraySet class.
     */
    final Object[] getArray() {
        return array;
    }
    //³õʼ»¯CopyOnWriteArrayListÏ൱ÓÚ³õʼ»¯Êý×é
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

    /**
     * Appends the specified element to the end of this list.
     *
     * @param e element to be appended to this list
     * @return {@code true} (as specified by {@link Collection#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 E get(int index) {
    return get(getArray(), index);
}

final Object[] getArray() {
    return array;
}

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

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

// °´ÕÕϱêɾ³ýÔªËØ
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) {
            // 0±íʾɾ³ýµÄÊÇÊý×éĩβµÄÔªËØ
            setArray(Arrays.copyOf(elements, len - 1));
        } else {
            // ´´½¨Ò»¸öÐÂÊý×飬³¤¶ÈÊÇÔ­Êý×鳤¶È-1
            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();
    }
}

static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }

        public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }

/**
* ÃèÊö£º ÑÝʾCopyOnWriteArrayListµü´úÆÚ¼ä¿ÉÒÔÐ޸ļ¯ºÏµÄÄÚÈÝ
*/

public class CopyOnWriteArrayListDemo {

    public static void main(String[] args) {
        CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>(new Integer[]{1, 2, 3});
        System.out.println(list); //[1, 2, 3]

        //Get iterator 1
        Iterator<Integer> itr1 = list.iterator();
        //Add one element and verify list is updated
        list.add(4);
        System.out.println(list); //[1, 2, 3, 4]
        //Get iterator 2
        Iterator<Integer> itr2 = list.iterator();
        System.out.println("====Verify Iterator 1 content====");
        itr1.forEachRemaining(System.out::println); //1,2,3
        System.out.println("====Verify Iterator 2 content====");
        itr2.forEachRemaining(System.out::println); //1,2,3,4

    }

}

[1, 2, 3]

[1, 2, 3, 4]

====Verify Iterator 1 content====

1

2

3

====Verify Iterator 2 content====

1

2

3

4