jdk1.8集合框架源码解析（七）CopyOnWriteArrayList源码解析

古城微笑少年丶 2021-12-16 23:49 297阅读 0赞

# 一、简介 #

> CopyOnWriteArrayList 是ArrayList的线程线程安全版本，其主要是通过volitle 修饰数组本事保证写操作对其他线程可见性，写操作是使用ReentrantLock加锁，每次对数组的写操作，都完全拷贝一份新的数组来修改，修改完了再替换掉老数组，这样保证了只阻塞写操作，不阻塞读操作，实现读写分离。

# 二、继承体系 #

public class CopyOnWriteArrayList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70][]

CopyOnWriteArrayList实现了List接口、RandomAccess（可随机访问）、Cloneable（可拷贝）、Serializable（可序列化）。

#  三、重要字段 #

/** The lock protecting all mutators */
        //用于写操作加锁，使用transient修饰表示不自动序列化。
        final transient ReentrantLock lock = new ReentrantLock();
    
        /** The array, accessed only via getArray/setArray. */
        //存储元素的地方，使用volatile修饰表示保证了写操作对其他线程的可见性，
        private transient volatile Object[] array;

# 四、构造函数 #

### 4.1、CopyOnWriteArrayList() ###

这里有对数组的set，get方法，所有对数组的操作都基于get，set方法

final Object[] getArray() {
        return array;
    }
    
    final void setArray(Object[] a) {
        array = a;
    }

创建空数组，把他赋值给CopyOnWriteArrayList

public CopyOnWriteArrayList() {
            setArray(new Object[0]);
       }

### 4.2、CopyOnWriteArrayList(Collection<? extends E> c) ###

public CopyOnWriteArrayList(Collection<? extends E> c) {
            Object[] elements;
            //如果c也是CopyOnWriteArrayList直接拿到他的数组进行赋值
            if (c.getClass() == CopyOnWriteArrayList.class)
                elements = ((CopyOnWriteArrayList<?>)c).getArray();
            else {
                elements = c.toArray();
                // c.toArray might (incorrectly) not return Object[] (see 6260652)
                if (elements.getClass() != Object[].class)
                    elements = Arrays.copyOf(elements, elements.length, Object[].class);
            }
            setArray(elements);
        }

c.toArray()返回的不一定是Object\[\]类型，具体可以查看jdk bug单 （单号6260652），这个bug jdk9已经解决.

地址为 [https://bugs.java.com/bugdatabase/view\_bug.do?bug\_id=6260652][https_bugs.java.com_bugdatabase_view_bug.do_bug_id_6260652]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 1][]

###  4.3、 CopyOnWriteArrayList(E\[\] toCopyIn) ###

public CopyOnWriteArrayList(E[] toCopyIn) {
            setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
        }

# 五、重要的方法 #

### 5.1、add(E e)方法 ###

public boolean add(E e) {
            final ReentrantLock lock = this.lock;
            //加锁
            lock.lock();
            try {
                //获取久的数组
                Object[] elements = getArray();
                int len = elements.length;
                //将旧数组copy到新数组中，新数组的长度为旧数组长度+1
                Object[] newElements = Arrays.copyOf(elements, len + 1);
                //把新加入的元素放在最后一位
                newElements[len] = e;
                //把新数组赋值给List
                setArray(newElements);
                return true;
            } finally {
                //解锁
                lock.unlock();
            }
        }

> （1）加锁；
> 
> （2）获取元素数组；
> 
> （3）新建一个数组，大小为原数组长度加1，并把原数组元素拷贝到新数组；
> 
> （4）把新添加的元素放到新数组的末尾；
> 
> （5）把新数组赋值给当前对象的array属性，覆盖原数组；
> 
> （6）解锁

### 5.2、add(int index, E element)方法 ###

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;
                 //为0代表插入的位置是最后一位
                if (numMoved == 0)
                   //拷贝数组给新数组，新数组的长度是老数组的长度+1
                    newElements = Arrays.copyOf(elements, len + 1);
                else {
                    //新建一个数组其长度是老数组的长度+1
                    newElements = new Object[len + 1];
                    //复制老数组index以前的元素给新数组
                    System.arraycopy(elements, 0, newElements, 0, index);
                    // 将index及其之后的元素往后挪一位拷贝到新数组中
                    //index位置空出来
                    System.arraycopy(elements, index, newElements, index + 1,
                                     numMoved);
                }
                //index位置赋值
                newElements[index] = element;
                //将数组赋值给List
                setArray(newElements);
            } finally {
                //解锁
                lock.unlock();
            }
        }

> ## ##
> 
> （1）加锁；
> 
> （2）检查索引是否合法，注意这里index等于len也是合法的；
> 
> （3）如果索引等于数组长度（也就是数组最后一位再加1），那就拷贝一个len+1的数组；
> 
> （4）如果索引不等于数组长度，那就新建一个len+1的数组，并按索引位置分成两部分，索引之前（不包含）的部分拷贝到新数组索引之前（不包含）的部分，索引之后（包含）的位置拷贝到新数组索引之后（不包含）的位置，索引所在位置留空；
> 
> （5）把索引位置赋值为待添加的元素；
> 
> （6）把新数组赋值给当前对象的array属性，覆盖原数组；
> 
> （7）解锁；

### 5.3、addIfAbsent(E e)方法 ###

public boolean addIfAbsent(E e) {
            Object[] snapshot = getArray();
            // 检查如果元素不存在与集合中,直接返回false
        
            // 如果存在再调用addIfAbsent()方法添加元素
            return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
                addIfAbsent(e, snapshot);
        }
        private boolean addIfAbsent(E e, Object[] snapshot) {
            final ReentrantLock lock = this.lock;
            lock.lock();
            try {
                // 重新获取旧数组
                Object[] current = getArray();
                int len = current.length;
                //不一致代表有修改
                // 重新检查元素是否在刚获取的数组里
                if (snapshot != current) {
                    // Optimize for lost race to another addXXX operation
                    int common = Math.min(snapshot.length, len);
                    for (int i = 0; i < common; i++)
                        
                        if (current[i] != snapshot[i] && eq(e, current[i]))
                            return false;
                    if (indexOf(e, current, common, len) >= 0)
                            return false;
                }
                
                // 拷贝一份n+1的数组
                Object[] newElements = Arrays.copyOf(current, len + 1);
                
                // 将元素放在最后一位
                newElements[len] = e;
            
                setArray(newElements);
                return true;
            } finally {
                //释放锁
                lock.unlock();
            }
        }

> （1）检查这个元素是否存在于数组快照中；
> 
> （2）如果存在直接返回false，如果不存在调用addIfAbsent(E e, Object\[\] snapshot)处理;
> 
> （3）加锁；
> 
> （4）如果当前数组不等于传入的快照，说明有修改，检查待添加的元素是否存在于当前数组中，如果存在直接返回false;
> 
> （5）拷贝一个新数组，长度等于原数组长度加1，并把原数组元素拷贝到新数组中；
> 
> （6）把新元素添加到数组最后一位；
> 
> （7）把新数组赋值给当前对象的array属性，覆盖原数组；
> 
> （8）解锁；

### 5.4、get(int index) ###

public E get(int index) {
            return get(getArray(), index);
        }
        @SuppressWarnings("unchecked")
        private E get(Object[] a, int index) {
            return (E) a[index];
        }

>  （1）获取元素数组；
> 
> （2）返回数组指定索引位置的元素；

### 5.5、remove(int index)方法 ###

public E remove(int index) {
            final ReentrantLock lock = this.lock;
            //加锁
            lock.lock();
            try {
                //获取老数组
                Object[] elements = getArray();
                int len = elements.length;
                //获取老数组index位置的元素
                E oldValue = get(elements, index);
                //移动元素的个数
                int numMoved = len - index - 1;
                //删除的是最后一位元素
                if (numMoved == 0)
                    //copy老数组到新数组中，拷贝长度为len-1，相当于删除最后一位元素
                    setArray(Arrays.copyOf(elements, len - 1));
                else {
                    //老一套，利用arraycopy方法完成元素的移除
                    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();
            }
        }

>  （1）加锁；
> 
> （2）获取指定索引位置元素的旧值；
> 
> （3）如果移除的是最后一位元素，则把原数组的前len-1个元素拷贝到新数组中，并把新数组赋值给当前对象的数组属性；
> 
> （4）如果移除的不是最后一位元素，则新建一个len-1长度的数组，并把原数组除了指定索引位置的元素全部拷贝到新数组中，并把新数组赋值给当前对象的数组属性；
> 
> （5）解锁并返回旧值；

### 5.6、size()方法 ###

public int size() {
            return getArray().length;
        }

## ##

*为什么CopyOnWriteArrayList没有size属性？*

*因为每次修改都是拷贝一份正好可以存储目标个数元素的数组，所以不需要size属性了，数组的长度就是集合的大小，而不像ArrayList数组的长度实际是要大于集合的大小的。*

*比如，add(E e)操作，先拷贝一份n+1个元素的数组，再把新元素放到新数组的最后一位，这时新数组的长度为len+1了，也就是集合的size了。*

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70]: /images/20211214/7442fcdbbae14e35a7b4ef965ac9f614.png
[https_bugs.java.com_bugdatabase_view_bug.do_bug_id_6260652]: https://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h6YXVfaXRkb2c_size_16_color_FFFFFF_t_70 1]: /images/20211214/1810f8f91d2043b5a970eead216e93e7.png