java多线程---CopyOnWriteArrayList解析

最新推荐文章于 2022-11-08 01:34:38 发布

Sasukeer

最新推荐文章于 2022-11-08 01:34:38 发布

阅读量248

点赞数

分类专栏： java-并发

本文链接：https://blog.csdn.net/wkztselina/article/details/87078741

版权

java-并发专栏收录该内容

8 篇文章 0 订阅

订阅专栏

CopyOnWriteArrayList

List是java三大集合中的一个，最最常见的就是ArrayList和LinkedList。简单来讲，ArrayList是数组的数据格式，当它不发生扩容的情况下，add的速度是比较快的。而LinkedList是一个双向链表的数据格式，不存在对容器的限定等等。

ArrayList和Vector的区别

Vector是线程安全的集合类，ArrayList并不是线程安全的类。Vector类对集合的元素操作时都加了synchronized，保证线程安全。
Vector与ArrayList本质上都是一个Object[] 数组，ArrayList提供了size属性，Vector提供了elementCount属性，他们的作用是记录集合内有效元素的个数。与我们平常调用的arrayList.size()和vector.size()一样返回的集合内有效元素的个数。
Vector与ArrayList的扩容并不一样，Vector默认扩容是增长一倍的容量，Arraylist是增长50%的容量。
Vector与ArrayList的remove,add(index,obj)方法都会导致内部数组进行数据拷贝的操作，这样在大数据量时，可能会影响效率。
Vector与ArrayList的add(obj)方法，如果新增的有效元素个数超过数组本身的长度，都会导致数组进行扩容。

CopyOnWriteArrayList是什么

那么在java中，多并发的情况越来越多，ArrayList并不是线程安全的类，而Vector是线程安全但是它的效率并不是那么的理想，java需要更快更安全的List。于是在1.5中，CopyOnWriteArrayList诞生了。

属性

首先看下CopyOnWriteArrayList的属性：

 /** 独占锁，保证只有一个线程可以获取 */
    final transient ReentrantLock lock = new ReentrantLock();

    /** 具体存放的列表数据 */
    private transient volatile Object[] array;

构造器

了解了，主要的构成，再看一下构造函数。

//无参构造函数，初始化一个0的数组
public CopyOnWriteArrayList() {
        setArray(new Object[0]);
}
//入参是集合，把集合的元素都复制到array中 
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) 此处是java官方给出的一个BUG
        if (elements.getClass() != Object[].class)
            elements = Arrays.copyOf(elements, elements.length, Object[].class);
    }
    setArray(elements);
}

bug 6260652详情见此

重点方法

add 方法，源码如下

//add的其中一个方法
 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);
            newElements[len] = e;
            //替换之前的数组
            setArray(newElements);
            return true;
        } finally {
            lock.unlock();
        }
    }

get方法

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

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

get的方法很简单，中规中矩，但是这边需要注意一个问题，由于get方法时并没有获取锁，所以如果当我的数组中存在[a,b,c]3个值，当线程一通过get(0),获取第一位时，线程二通过remove方法，移除了第一位，于是线程一获取到的就不是a,而是b了。也是写时复制策略产生的弱一致性的问题。

set方法

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

remove方法

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 {
            
            //分2次复制删除后的元素到数组
                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();
        }
    }

迭代器

static final class COWIterator<E> implements ListIterator<E> {
        /** 数组的临时快照 */
        private final Object[] snapshot;
        /** 数组下标  */
        private int cursor;
        
        //在构造器中可以看到，当CopyOnWriteArrayList，在使用迭代器的时候，是在迭代器内部复制一个数组的快照版本。因此，当使用该迭代器时，其他线程对list的操作，对迭代器来说是不可见的。因为他们操作的是2个不同的数组
        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }
        //获取元素
         public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }
        ....

总结

由上面的几个重要方法中，可以看到以下几个特性

在CopyOnWriteArrayList中，list是没有个数限制的
CopyOnWriteArrayList整体都是采用了复制策略进行操作，都没有直接在它自身的数组上进行操作，而是建立一个新的数组，在新的数组上进行操作以后，替换原来的数组。
CopyOnWriteArrayList采用了独占锁来控制线程的安全性。
CopyOnWriteArrayList的迭代器中可以隔离其他的修改操作。

开工快乐

bug 6260652

根据官方的介绍，再结合个人的理解，可以简单概括如下：

产生的原因：因为java存在继承的特性，在做类型转换的时候会出现错误情况。
例子：SubClass是子类，BaseClass是父类，如下

 SubClass[] subArray = {new SubClass(), new SubClass()};
 BaseClass[] baseArray = subArray;
 //这个情况下是不会出现问题的，因为这个是java对象的向上转型，子类数组转为父类数组。但是由于数组中，已经存了SubClass。所以如下操作会报错。
 baseArray[0] = new BaseClass();
 //也就是说当我们拥有一个Object[]的数组时，并不代表真的可以把Object对象存进去，这个取决于数组中的实际类型。