编程语言
首页 > 编程语言> > CopyOnWriteArrayList源码分析

CopyOnWriteArrayList源码分析

作者:互联网

CopyOnWriteArrayList是ArrayList的线程安全版本,内部也是通过数组实现,

每次对数组的修改都完全拷贝一份新的数组来修改,修改完了再替换掉老数组

,这样保证了只阻塞写操作,不阻塞读操作,实现读写分离

 

从里面增删改查来看还是调用最底层的方法:

         Object[] newElements = new Object[newlen];
                System.arraycopy(elements, 0, newElements, 0, fromIndex);
                System.arraycopy(elements, toIndex, newElements,
                                 fromIndex, numMoved);
                setArray(newElements);

调用的是操作系统的方法:

  public static native void arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);

只是在实现上比arraylist更加复杂:

  private static final long serialVersionUID = 8673264195747942595L;

    /** The lock protecting all mutators  用于修改时候锁*/
    final transient ReentrantLock lock = new ReentrantLock();

    /** The array, accessed only via getArray/setArray. */
    private transient volatile Object[] array;

(1)lock

用于修改时加锁,使用transient修饰表示不自动序列化。

(2)array

真正存储元素的地方,使用transient修饰表示不自动序列化,使用volatile修饰表示一个线程对这个字段的修改另外一个线程立即可见。

那么为什么没有ArrayList中的size属性呢:

 //无参构造方法
public CopyOnWriteArrayList() { setArray(new Object[0]); } //带集合的构造方法 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); } //把tocopyIn中内容添加到集合中 public CopyOnWriteArrayList(E[] toCopyIn) { setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class)); } //是一种方法,不是作为属性 public int size() { return getArray().length; }

由此可以得知,是通过方法来获取的长度的

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

(1)加锁;

(2)获取元素数组;

(3)新建一个数组,大小为原数组长度加1,并把原数组元素拷贝到新数组;

(4)把新添加的元素放到新数组的末尾;

(5)把新数组赋值给当前对象的array属性,覆盖原数组;

(6)解锁;

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

(1)加锁;

(2)检查索引是否合法,如果不合法抛出IndexOutOfBoundsException异常,注意这里index等于len也是合法的;

(3)如果索引等于数组长度(也就是数组最后一位再加1),那就拷贝一个len+1的数组;

(4)如果索引不等于数组长度,那就新建一个len+1的数组,并按索引位置分成两部分,索引之前(不包含)的部分拷贝到新数组索引之前(不包含)的部分,索引之后(包含)的位置拷贝到新数组索引之后(不包含)的位置,索引所在位置留空;

(5)把索引位置赋值为待添加的元素;

(6)把新数组赋值给当前对象的array属性,覆盖原数组;

(7)解锁;

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

(1)加锁;

(2)获取指定索引位置元素的旧值;

(3)如果移除的是最后一位元素,则把原数组的前len-1个元素拷贝到新数组中,并把新数组赋值给当前对象的数组属性;

(4)如果移除的不是最后一位元素,则新建一个len-1长度的数组,并把原数组除了指定索引位置的元素全部拷贝到新数组中,并把新数组赋值给当前对象的数组属性;

(5)解锁并返回旧值;

 

为什么CopyOnWriteArrayList没有size属性?

因为每次修改都是拷贝一份正好可以存储目标个数元素的数组,所以不需要size属性了,数组的长度就是集合的大小,而不像ArrayList数组的长度实际是要大于集合的大小的。

比如,add(E e)操作,先拷贝一份n+1个元素的数组,再把新元素放到新数组的最后一位,这时新数组的长度为len+1了,也就是集合的size了。

 

标签:分析,elements,lock,Object,len,CopyOnWriteArrayList,源码,newElements,数组
来源: https://www.cnblogs.com/xiufengchen/p/10722783.html