JAVA并发编程高级-线程安全集合-CopyOnWriteArrayList

CopyOnWriteArrayList        

        并发包中的并发 List 只有 CopyOnWriteArrayList。CopyOnWriteArrayList是一个线程安全的 ArrayList，对其进行的修改操作都是在底层的一个复制的数组(快照)上进行的，也就是使用了写时复制策略。Copy On WriteArraylist 的类图结构如图 5-1所示。

        在 CopyOnWriteArrayList的类图中，每个CopyOnWriteArrayList 对象里面有一个array 数组对象用来存放具体元素，ReentrantLock独占锁对象用来保证同时只有一个线程对 array 进行修改。这里只要记得 ReentrantLock 是独占锁，同时只有一个线程可以获取就可以了，后面会专门对 JUC 中的锁进行介绍。
如果让我们自己做一个写时复制的线程安全的list我们会怎么做,有哪些点需要考虑?

·何时初始化 list，初始化的 list 元素个数为多少，list 是有限大小吗?
·如何保证线程安全，比如多个线程进行读写时如何保证是线程安全的?
·如何保证使用迭代器遍历 list时的数据一致性?

        下面我们看看 CopyOnWriteArrayList 的作者 Doug Lea 是如何设计的。

构造方法

首先看下无参构造函数，如下代码在内部创建了一个大小为0的Object数组作为array 的初始值。

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

//创建一个list，其内部元素是入参tocopyIn的副本 --基于数组的构造方法

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

//入参为集合，将集合里面的元素复制到本list--基于集合的构造方法

    public CopyOnWriteArrayList(Collection<? extends E> c) {
        Object[] elements;
        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);
    }

常用方法

添加元素

add(E e)

  public boolean add(E e) {
        //获取独占锁（ 1 ) 
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            //获取array（2）
            Object[] elements = getArray();
            //(3 ）复制array到新数组 添加元素到新数组
            int len = elements.length;
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            newElements[len] = e;
            //（4）使用新数组替换添加前的数组
            setArray(newElements);
            return true;
        } finally {
            // (5 ）择放独占锁
            lock.unlock();
        }
    }

        在如上代码中，调用add方法的线程会首先执行代码(1)去获取独占锁，如果多个线程都调用 add方法则只有一个线程会获取到该锁,其他线程会被阻塞挂起直到锁被释放。

        所以一个线程获取到锁后，就保证了在该线程添加元素的过程中其他线程不会对array 进行修改。

        线程获取锁后执行代码(2)获取aray，然后执行代码(3)复制array到一个新数组(从这里可以知道新数组的大小是原来数组大小增加1，所以CopyOnWriteArrayList 是无界 1ist),并把新增的元素添加到新数组。

        然后执行代码(4)使用新数组替换原数组，并在返回前释放锁。由于加了锁，所以整个 add 过程是个原子性操作。需要注意的是，在添加元素时，首先复制了一个快照，然后在快照上进行添加，而不是直接在原来数组上进行。

获取指定位置元素

         E get(int index)

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

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

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

        在如上代码中，当线程x调用get方法获取指定位置的元素时，分两步走，首先获取array 数组(这里命名为步骤A),然后通过下标访问指定位置的元素(这里命名为步骤B),这是两步操作,但是在整个过程中并没有进行加锁同步。假设这时候List内容如图5-2所示，里面有 1、2、3 三个元素。

        由于执行步骤A和步骤B没有加锁，这就可能导致在线程x执行完步骤A后执行步骤B前，另外一个线程y进行了remove操作，假设要删除元素1。remove 操作首先会获取独占锁，然后进行写时复制操作，也就是复制一份当前array数组，然后在复制的数组里面删除线程x通过 get方法要访问的元素1，之后让 array 指向复制的数组。而这时候array之前指向的数组的引用计数为1而不是0，因为线程x还在使用它，这时线程x开始执行步骤 B，步骤 B操作的数组是线程y删除元素之前的数组，如图5-3所示。

所以，虽然线程y已经删除了index处的元素，但是线程x的步骤B还是会返回index 处的元素，这其实就是写时复制策略产生的弱一致性问题。

修改指定元素

 E set(int index, E element)

     使用 E set(int index,E element)修改 list 中指定元素的值，如果指定位置的元素不存在则抛出 IndexOutOfBoundsException 异常，代码如下。

 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);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

   

        如上代码首先获取了独占锁，从而阻止其他线程对array数组进行修改，然后获取当前数组，并调用get方法获取指定位置的元素，如果指定位置的元素值与新值不一致则创建新数组并复制元素，然后在新数组上修改指定位置的元素值并设置新数组到array。如果指定位置的元素值与新值一样，则为了保证 volatie 语义，还是需要重新设置 array，虽然array的内容并没有改变

删除元素

 E remove(int index)

        删除 list 里面指定的元素,可以使用 Eremove(int index)、boolean remove(Object o)和boolean remove(Object o,Object[]snapshot,int index)等方法，它们的原理一样。下面讲解下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];
                System.arraycopy(elements, 0, newElements, 0, index);
                System.arraycopy(elements, index + 1, newElements, index,
                                 numMoved);
                //使用新数组代替老数组
                setArray(newElements);
            }
            return oldValue;
        } finally {
               //释放锁
            lock.unlock();
        }
    }

        如上代码其实和新增元素的代码类似，首先获取独占锁以保证删除数据期间其他线程不能对 array 进行修改，然后获取数组中要被删除的元素，并把剩余的元素复制到新数组,之后使用新数组替换原来的数组，最后在返回前释放锁。