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

比眉伴天荒 2022-06-08 08:23 182阅读 0赞

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

--------------------