浅谈CopyOnWriteArrayList

CopyOnWriteArrayList结构图

image.png

CopyOnWriteArrayList主要方法

• public void add(E e)
• public E get(int index)
• public E set(int index, E element)
• public E remove(int index)

CopyOnWriteArrayList解读主要方法

来看一下public void add(E e)的源代码：

public boolean add(E e) {
        //加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
             //获取原来数组以及数组长度
            Object[] elements = getArray();
            int len = elements.length;
            //重新申请一个数组长度加一
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //新的元素放入新的数组
            newElements[len] = e;
            //重新设置新的数组
            setArray(newElements);
            return true;
        } finally {
            //解锁
            lock.unlock();
        }
    }

从代码来看还是很好理解的，先获取锁，然后创建一个新的数组再往新的数组添加对应的元素，然后需要重新设置一个数组，最后释放掉锁。
来看一下public E get(int index)的源码：

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

来看一下public E set(int index, E element)源码：

  public E set(int index, E element) {
        //还是先加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取原来数组和index对应的数据
            Object[] elements = getArray();
            E oldValue = get(elements, index);
            //当前元素和老的元素不一样的时候，重新创建一个数组，把原来index为的元素换成新的元素，重置数组
            if (oldValue != element) {
                int len = elements.length;
                Object[] newElements = Arrays.copyOf(elements, len);
                newElements[index] = element;
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
          //释放锁座
            lock.unlock();
        }
    }

这个理解起来也还好，就是先加锁，然后创建一个新的数组把原来的index位置的元素换成新的元素，重置一下数据，最后释放锁座。
来看一下public E remove(int index)的源码

 public E remove(int index) {
        //老规矩先加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取数据并且获取index位置原来的数据
            Object[] elements = getArray();
            int len = elements.length;
            E oldValue = get(elements, index);
            //判断index的位置
            int numMoved = len - index - 1;
            //删除元素在最后
            if (numMoved == 0)
                setArray(Arrays.copyOf(elements, len - 1));
            else {
                //新创建一个数组，长度为原来的-1
                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();
        }
    }

这个方法也比较好理解，总结起来就是先加锁，然后确定删除的位置，除了老的元素，复制到新的数组里，最好解锁。

CopyOnWriteArrayList遍历介绍

常用的三种遍历方式：

      //one  foreach  遍历
        for (Object o : list) {
            System.out.println(o);
        }
        // two 随机访问
        for (int i = 0; i <list.size(); i++) {
            System.out.println(list.get(i));
        }
        //three 迭代器的遍历
        Iterator iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

CopyOnWriteArrayList其他特性介绍

• CopyOnWriteArrayList对比ArrayList首先它是线程安全，由于它有lock支持；其次CopyOnWriteArrayList没有容量的概念，不会有判断是否需要扩容，因为他的每一次增删改都是操作一个新的数组。
• 它的效率相比ArrayList是更低的因为它需要频繁的创建数组，它是不会抛ConcurrentModificationException异常的。
• CopyOnWriteArrayList假设一个线程set操作，位置为index，另外一个线程remove,位置也为index，此时为什么不会报错呢？因为有ReentrantLock，ReentrantLock是独占锁，当有线程占用的时候，其他线程只能等待。