CopyOnWriteArrayList设计思路与源码分析

CopyOnWriteArrayList实现了List接口，RandomAccess，Cloneable，Serializable接口。

CopyOnWriteArrayList特性

1、线程安全，在多线程环境下作为共享变量可以放心使用，无需加锁。
2、通过加锁和volatile保证安全
3、每次对数组进行增删改操作都会复制原先元素到新的数组中，在新的数组上进行操作，最后再赋值回去。

他底层使用的数据结构也是数组，对数组中元素的操作都会经历，加锁，拷贝原数组到新数组中，对新数组进行增删改，然后赋值回旧的数组，最后解锁。

除了这些操作外，CopyOnWriteArrayList内的array数组是被volatile和transient修饰的。

类注释

从类注释中，我们可以知道CopyOnWriteArrayList是线程安全的集合类，因为增删改都是在新的数组中进行的，当更新完成后，新数组又被赋值给原先数组，这样所有线程都可以知道哪些元素被修改了。
虽然数组的拷贝开销较大，但是往往比常用的方案效率要好。
在迭代过程中，不会抛出ConcurrentModificationException，因为并不是在原先数组上修改的。

新增

public boolean add(E e) {

        final ReentrantLock lock = this.lock;

        // 手动加锁

        lock.lock();

        try {

        	// 旧数组

            Object[] elements = getArray();

            // 原先数组长度

            int len = elements.length;

            // 新数组是旧数组的拷贝，且容量+1

            Object[] newElements = Arrays.copyOf(elements, len + 1);

            // 直接将新元素e赋值给新数组的最后

            newElements[len] = e;

            // 设置给原数组array，array = newElements

            setArray(newElements);

            return true;

        } finally {

        // 最后释放锁

            lock.unlock();

        }

    }

在整个add的过程中都是加锁的，所以在同一时刻只有一个线程可以add成功，既然已经加锁，那为什么还要创建新数组进行拷贝呢？这是因为原先数组是volatile修饰的，如果我们简单的在原来数组上修改其中某几个元素的值，是无法触发可见性的，我们必须通过修改数组的内存地址才行，也就说要对数组进行重新赋值才行。通过新建一个数组拷贝旧的数组，是可以避免在赋值过程中出现旧数组值被改变的情况。

当在指定位置插入时，如果插入元素的位置时最后一个，那么只需要拷贝一次，如果在中间位置插入时，需要拷贝两次(将数组一分为二)；

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

        }

    }

删除

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

            // 减一是因为len是从1开始的，index是从0开始的

            int numMoved = len - index - 1;

            if (numMoved == 0)// 如果删除的是最后一个，直接删除

                setArray(Arrays.copyOf(elements, len - 1));

            else {

            // 如果删除的是中间元素，新建的数组大小-1，并且从0拷贝到删除元素前，从删除元素的后一个拷贝到最后

                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、解锁
不管事新增还是删除，lock对象都是被final修饰的，他们都共用一把锁，try finally+数组拷贝保证了能够成功删除指定元素。

小结

该集合类的优点是：读取元素不需要加锁，适合读多写少的场景。例如：读取白名单，黑名单等。
缺点也很明显：内存开销比在原数组上修改多了一倍内存占用，可能导致年轻代GC，如果要求强一致性就不能使用这个了。

巴特西

CopyOnWriteArrayList设计思路与源码分析

CopyOnWriteArrayList特性

类注释

新增

删除

小结

最新文章

热门文章