欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

CopyOnWriteArrayList分析

程序员文章站 2022-07-14 16:09:53
...

CopyOnWriteArrayList分析

1. 属性开始


    private static final long serialVersionUID = 8673264195747942595L;

    // 排他锁
    final transient ReentrantLock lock = new ReentrantLock();

 // 数组的方法是通过getArray和setArray
    private transient volatile Object[] array;

2. 构造方法开始

  1. 无参构造
// 给array赋,赋一个Object[0]的数组,没有啥子长度的数组
public CopyOnWriteArrayList() {
        setArray(new Object[0]);
  }
  1. 传递一个collection

    传递进来c变为数组,通过Arrays.copyOf拷贝一个新的数组,赋值给elements,关于Arrays.copyOf,这底层就是调用System.arraycopy方法。

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

剩下的api基本就是操作数组元素的了,在ArrayList分析过,这里就在累赘的说了。下面主要分析一下add,set方法和get方法。

add 方法分析

这里的逻辑也很简单了,获取锁,每次都是利用拷贝数组,每次都先拷贝一个length + 1长度的新数组,在最后一个位置放新的数据

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

set(int index, E element) 分析

替换指定下标的元素。如果指定的位置没有元素,就将数组重新设置回去。

如果指定的位置有值,注意,这里比较采用的还是 引用比较。不一样的话,就会重新拷贝一份,然后指定位置下标,获得新数组,然后重新设置值。

 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;
               // 重新设置新数组,在volatile修饰的变量,能让值强制刷新会工作内存,并且会使别的线程获取值的时候从工作内存中获取值。包装内存一致性
                setArray(newElements);
            } else {
                // Not quite a no-op; ensures volatile write semantics
                setArray(elements);
            }
            return oldValue;
        } finally {
            lock.unlock();
        }
    }

get方法分析

get方法很简单,就是通过下标获取数组中的对应的元素。着实很简单。

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

remove(int index) 方法分析

这里并没有想ArrayList一样,直接在原来的数组上面操作,而是重新new了一个数组,然后复制过去。

问题?

  1. 为什么这么做?

    数组对象的分配是在堆里面的,直接利用 System.arraycopy 操作原来的数组,不能保证内存的一直性,因为没有赋值(==)操作,所以,这里要重新创建数组,之后调用setArray方法设置值。

public E remove(int index) {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        Object[] elements = getArray();
        int len = elements.length;
        // 或者index的元素
        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,只要记住,只要涉及到变更的操作,都要创建新数组,在新的数组上面操作,之后通过set方法将新的数组set进去。

问题?

  1. 每次获取的时候ReentrantLock都有加锁和解锁的操作,为啥还要用volatile来修饰。

    ReentrantLock是javaApi来实现的,主要还是通过Park和unPark来阻塞线程,只能保证原子性。

    CopyOnWriteArrayList里面用volatile修饰array能保证内存一致性。

迭代器

CopyOnWriteArrayList 的迭代器和ArrayList大多数集合不一样,这里没有快速失败的机制。那就说明,在迭代器和CopyOnWriteArrayList 里面没有modCount操作。也没有检查的机制。

COWIterator的迭代器不支持remove,set,add操作,所以在ArrayList分析里面列举的例子在 CopyOnWriteArrayList 场景下面不会出错。

  public Spliterator<E> spliterator() {
        return Spliterators.spliterator
            (getArray(), Spliterator.IMMUTABLE | Spliterator.ORDERED);
    }

    static final class COWIterator<E> implements ListIterator<E> {
        /** Snapshot of the array */
        private final Object[] snapshot;
        /** Index of element to be returned by subsequent call to next.  */
        private int cursor;

        private COWIterator(Object[] elements, int initialCursor) {
            cursor = initialCursor;
            snapshot = elements;
        }

        public boolean hasNext() {
            return cursor < snapshot.length;
        }

        public boolean hasPrevious() {
            return cursor > 0;
        }

        @SuppressWarnings("unchecked")
        public E next() {
            if (! hasNext())
                throw new NoSuchElementException();
            return (E) snapshot[cursor++];
        }

        @SuppressWarnings("unchecked")
        public E previous() {
            if (! hasPrevious())
                throw new NoSuchElementException();
            return (E) snapshot[--cursor];
        }

        public int nextIndex() {
            return cursor;
        }

        public int previousIndex() {
            return cursor-1;
        }

        /**
         明显看到,这操作都是不支持的。直接抛出异常
         */
        public void remove() {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code set}
         *         is not supported by this iterator.
         */
        public void set(E e) {
            throw new UnsupportedOperationException();
        }

        /**
         * Not supported. Always throws UnsupportedOperationException.
         * @throws UnsupportedOperationException always; {@code add}
         *         is not supported by this iterator.
         */
        public void add(E e) {
            throw new UnsupportedOperationException();
        }

        @Override
        public void forEachRemaining(Consumer<? super E> action) {
            Objects.requireNonNull(action);
            Object[] elements = snapshot;
            final int size = elements.length;
            for (int i = cursor; i < size; i++) {
                @SuppressWarnings("unchecked") E e = (E) elements[i];
                action.accept(e);
            }
            cursor = size;
        }
    }

总结

  1. ArrayList 线程安全的代替类。多线程的情况下使用。
  2. 不支持通过迭代器来操作List。
  3. 没有快速失败机制
  4. 每次只要涉及到更改,就会从拿到数组,复制新数组,用新数组赋值。利用volatile来实现内存一致性。
  5. 复制数组耗费内存空间,导致内存空间的利用率低。所以,在读多写少的情况下,使用还是很不错的。但是话说回来,在写操作多的情况下,感觉也差不了多少。锁只有一把,肯定不会造成多个线程同时复制,无非也就是拷贝的操作在一个时间段之内多了点。
  6. CopyOnWriteArraySet是基于CopyOnWriteArrayList实现的,主要是利用addIfAbsent方法。先查找,如果没有查找到就添加
相关标签: Java并发 java