JAVA 并发类（四） CopyOnWriteArrayList 源码分析

1. 创建：CopyOnWriteArrayList()
2. 添加元素： add(E)
3. 获取单个对象：get(int)方法
4. 删除对象：remove(E)方法
5. 遍历所有对象：iterator()

CopyOnWriteArrayList是一个线程安全，读操作无锁的ArrayList

创建

public CopyOnWriteArrayList()

使用方法

List<String> list = new CopyOnWriteArrayList<String>();

源码：

private volatile transient Object[] array;//底层数据结构

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

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

    /**
     * 创建一个CopyOnWriteArrayList
     * 注意：创建了一个0个元素的数组
     */
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

和ArrayLIst一样，未指定容量默认创建容量为10的数组

添加元素

public boolean add(E e)

使用方法

list.add("hello");

源码：

/**
 * 在数组末尾添加元素
 * 1）获取锁
 * 2）上锁
 * 3）获取旧数组及其长度
 * 4）创建新数组，容量为旧数组长度+1，将旧数组拷贝到新数组
 * 5）将要增加的元素加入到新数组的末尾，设置全局array为新数组
 */
public boolean add(E e) {
    final ReentrantLock lock = this.lock;
    lock.lock();//上锁
    try {
        Object[] elements = getArray();//获取当前的数组
        int len = elements.length;//获取当前数组元素
        /*
         * Arrays.copyOf(elements, len + 1)的大致执行流程：
         * 1）创建新数组，容量为len+1，
         * 2）将旧数组elements拷贝到新数组，
         * 3）返回新数组
         */
        Object[] newElements = Arrays.copyOf(elements, len + 1);
        newElements[len] = e;//新数组的末尾元素设成e
        setArray(newElements);//设置全局array为新数组
        return true;
    } finally {
        lock.unlock();//解锁
    }
}

获取元素

/**
     * 根据下标获取元素
     * 1）获取数组array
     * 2）根据索引获取元素
     */
    public E get(int index) {
        return (E) (getArray()[index]);
    }

获取元素的时候不会加锁

删除元素

操作流程：
1.获取锁 加锁
2.获取旧数组，旧数组的长度len
3.如果旧数组长度为0 返回false
4.如果旧数组有值，创建一个新数组，容量为len-1
5.从0开始遍历数组中除了最后一个元素的所有元素
5.1 把旧数组中被删除元素之前的元素复制到新数组中
5.2 那旧数组中被删除元素之后的元素复制到新数组中
6.如果是要删除旧数组中的最后一个元素
6.1 把旧数组中被删除元素之前的元素复制到新数组中
6.2 把新数组赋给全局array

public boolean remove(Object o) {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();//获取原数组
            int len = elements.length;//获取原数组长度
            if (len != 0) {//如果有数据
                // Copy while searching for element to remove
                // This wins in the normal case of element being present
                int newlen = len - 1;//新数组长度为原数组长度-1
                Object[] newElements = new Object[newlen];//创建新数组

                for (int i = 0; i < newlen; ++i) {//遍历新数组（不包含最后一个元素）
                    if (eq(o, elements[i])) {
                        // 将旧数组中将被删除元素之后的元素复制到新数组中
                        for (int k = i + 1; k < len; ++k)
                            newElements[k - 1] = elements[k];
                        setArray(newElements);//将新数组赋给全局array
                        return true;
                    } else
                        newElements[i] = elements[i];//将旧数组中将被删除元素之前的元素复制到新数组中
                }

                if (eq(o, elements[newlen])) {//将要删除的元素时旧数组中的最后一个元素
                    setArray(newElements);
                    return true;
                }
            }
            return false;
        } finally {
            lock.unlock();
        }
    }

总结

• CopyOnWriteArrayList是线程安全且读操作时无锁的ArrayList.
• 底层使用数组Object[]实现，初始容量为0，之后每增加一个元素，容量+1，数组复制一遍。
• 增删操作上锁 读操作不加锁
• 读多写少且脏读影响不大的情况下，选择CopyOnWriteArrayList

---