CopyOnWriteArrayList源码（一）

前言

CopyOnWriteArrayList是ArrayList的线程安全版，采用ReentrantLock保证线程安全。
因为底层是创建新的数组，然后更新引用地址，所以没有扩容相关方法。
因CopyOnWriteArrayList在写的时候会创建新数组，占用JVM内存，可能会引发频繁GC， 因此更适用于读多写少的并发场景。

1. CopyOnWriteArrayList类图

2. 基础属性

1. 序列化

private static final long serialVersionUID = 8673264195747942595L;

2. 禁止序列化的可重入锁

//transient禁止序列化
final transient ReentrantLock lock = new ReentrantLock();

3. volatile 关键字修饰的数组

private transient volatile Object[] array;

4. get方法

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

5. set方法

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

3. 构造函数

1. CopyOnWriteArrayList()——无参构造

    public CopyOnWriteArrayList() {
        setArray(new Object[0]); //创建一个空列表
    }

2. CopyOnWriteArrayList(Collection<? extends E> c)——集合入参构造

	public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements; //声明数组
        if (c.getClass() == CopyOnWriteArrayList.class) //如果入参为CopyOnWriteArrayList实例
            elements = ((CopyOnWriteArrayList<?>)c).getArray(); //强转赋值
        else { //非CopyOnWriteArrayList实例
            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); //setter
    }

3. CopyOnWriteArrayList(E[] toCopyIn)——数组入参构造

    public CopyOnWriteArrayList(E[] toCopyIn) {
    	//复制数组到新CopyOnWriteArrayList
        setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
    }

4.新增元素

1. add(E e)——指定元素

	public boolean add(E e) {
        final ReentrantLock lock = this.lock; //该实例锁
        lock.lock(); //获取锁
        try {
            Object[] elements = getArray(); //get元素数组
            int len = elements.length; //获取长度
            Object[] newElements = Arrays.copyOf(elements, len + 1); //增加数组长度1
            newElements[len] = e; //数组最后索引赋值为指定元素e
            setArray(newElements); //把数组引用更新为newElements的
            return true; //返回添加结果
        } finally {
            lock.unlock(); //释放锁
        }
    }

2. add(int index, E element)——在指定索引新增一个元素，后续元素右移1位

    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]; //数组长度+1
                System.arraycopy(elements, 0, newElements, 0, index); //复制index前面的元素
                System.arraycopy(elements, index, newElements, index + 1, //复制index后面的元素
                                 numMoved);
            }
            newElements[index] = element; //执行add，在指定索引index赋值指定元素e
            setArray(newElements); //更新数组引用
        } finally {
            lock.unlock(); //释放锁
        }
    }

5. 删除元素

1. remove(int index)——入参为索引

    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]; //声明一个-1容量的新数组
                System.arraycopy(elements, 0, newElements, 0, index); //复制index前的元素
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved); //复制index后的元素
                setArray(newElements); //更新数组引用
            }
            return oldValue; //返回旧元素
        } finally {
            lock.unlock(); //释放锁
        }
    }

2. remove(Object o)——入参为指定元素

    public boolean remove(Object o) { //指定元素
        Object[] snapshot = getArray(); //获取数组快照
        int index = indexOf(o, snapshot, 0, snapshot.length); //从快照获取指定元素索引
        return (index < 0) ? false : remove(o, snapshot, index); //返回执行结果
    }

indexOf(Object o, Object[] elements, int index, int fence)——从指定数组索引范围内返回指定元素

    private static int indexOf(Object o, Object[] elements,
                               int index, int fence) { //目标元素、数组、起始索引、终止索引
        if (o == null) { //指定元素为null
            for (int i = index; i < fence; i++) //在指定范围内[index,fence)查询
                if (elements[i] == null)
                    return i;
        } else {
            for (int i = index; i < fence; i++) //在指定范围内[index,fence)查询
                if (o.equals(elements[i]))
                    return i;
        }
        return -1; //没指定元素，返回-1
    }

remove(Object o, Object[] snapshot, int index)——删除指定元素

    private boolean remove(Object o, Object[] snapshot, int index) { //目标元素、快照数组、指定索引
        final ReentrantLock lock = this.lock; //声明实例锁
        lock.lock(); //获取锁
        try {
            Object[] current = getArray(); //获取集合元素数组current
            int len = current.length; //获取数组长度
            if (snapshot != current) findIndex: {  //如果快照snapshot与current不一致，搜索索引
                int prefix = Math.min(index, len); //从最短的算
                for (int i = 0; i < prefix; i++) { //遍历current
                    if (current[i] != snapshot[i] && eq(o, current[i])) { //在current找到目标元素
                        index = i; //修正目标元素的索引
                        break findIndex; //终止
                    }
                }
                if (index >= len) //如果目标索引越界
                    return false; //删除失败
                if (current[index] == o) //终止其余线程的findIndex
                    break findIndex;
                index = indexOf(o, current, index, len); //重新在current里获取目标索引
                if (index < 0)
                    return false;
            }
            Object[] newElements = new Object[len - 1]; //容量-1的数组
            System.arraycopy(current, 0, newElements, 0, index); //复制元素[0,index)
            System.arraycopy(current, index + 1,
                             newElements, index,
                             len - index - 1); //复制元素，索引 [index+1,len) 到 [index,len-1)
            setArray(newElements); //更新数组引用
            return true; //删除成功
        } finally {
            lock.unlock(); //释放锁
        }
    }

eq(Object o1, Object o2)——判断两元素是否相等

    private static boolean eq(Object o1, Object o2) {
        return (o1 == null) ? o2 == null : o1.equals(o2);
    }

3. clear()——清空数组

    public void clear() {
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            setArray(new Object[0]);
        } finally {
            lock.unlock();
        }
    }

6. 修改元素

1. set(int index, E element) —— 指定索引及元素

	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); //更新数组引用为newElements的
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements); //新旧元素一致,重新写入一次以防万一
            }
            return oldValue; //返回指定索引 原元素
        } finally {
            lock.unlock(); //释放锁
        }
    }

7. 查询元素

1. get(int index)——指定索引

    public E get(int index) {
        return get(getArray(), index);
    }

    private E get(Object[] a, int index) {
        return (E) a[index]; //异常是继承至
    }