看jetty源碼時看到的CopyOnWrite容器

1、首先說說CopyOnWrite容器是幹啥的：

在jdk中CopyOnWrite容器有兩個，一個是CopyOnWriteArrayList，另一個是CopyOnWriteArraySet，CopyOnWriteArrayList是List的子類，
CopyOnWriteArraySet是Set的子類，這兩個類達到的目標都是實現線程安全的，先目睹一下CopyOnWriteArrayList的源碼

本類中定義的屬性

private static final long serialVersionUID = 8673264195747942595L;

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

    /** The array, accessed only via getArray/setArray. */
    private volatile transient Object[] array;

上面的三個屬性：第一個是序列化版本ID，和JVM有關;第二個是可重入鎖ReentrantLock，這個屬性是不可更改的（final）和不被序列化的（transient），第三個是volatile transient的對象數組
下面看看CopyOnWriteArrayList的添加和刪除的方法實現

1. 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();
        }
    }

2. 在數組最後添加元素的Add方法

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);
            newElements[len] = e;
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

3. 在數組中替換元素的Add方法

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

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

5. addAll方法

public boolean addAll(Collection<? extends E> c) {
        Object[] cs = c.toArray();
        if (cs.length == 0)
            return false;
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + cs.length);
            System.arraycopy(cs, 0, newElements, len, cs.length);
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

.。。。。。。。
從上面所有的方法可以看出，所有操作array的方法都會鎖住，然後複製一份，再操作複本，完成之後再讓array指向新的地址。這樣也不難想到這是一個線程安全的類，對於讀取屬性array沒有添加鎖，也就是在讀取的時候可能會讀取到舊數據，在修改屬性array中添加了鎖，也就是在添加的時候是線程安全的。
從jdk api文檔也可以看到的說法是這是ArrayList的線程安全的一個變體。
2、CopyOnWrite容器有什麼用處
這個類的出現讓我想到了項目中的一些寫在config配置文件中的和寫在數據表中的一些系統配置可以使用該類實現，當然這個是絕對不能用來做併發時的自增的啦。