CopyOnWriteArrayList详解

最新推荐文章于 2024-10-24 16:20:07 发布

转载最新推荐文章于 2024-10-24 16:20:07 发布 · 752 阅读

文章标签：

#线程安全 #多线程 #高性能 #并发 #arraylist

本文详细介绍了CopyOnWriteArrayList的工作原理及其应用场景。这是一种线程安全的ArrayList变体，通过复制底层数组来实现所有可变操作，适用于读操作远多于写操作的场景。

发表于5个月前(2013-10-08 11:54) 阅读（ 519） | 评论（ 0） 8人收藏此文章, 我要收藏

CopyOnWriteArrayList thread CopyOnWriteArraySet

CopyOnWriteArrayList是ArrayList 的一个线程安全的变体，其中所有可变操作（add、set等等）都是通过对底层数组进行一次新的复制来实现的。

这一般需要很大的开销，但是当遍历操作的数量大大超过可变操作的数量时，这种方法可能比其他替代方法更有效。在不能或不想进行同步遍历，但又需要从并发线程中排除冲突时，它也很有用。“快照”风格的迭代器方法在创建迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改，因此不可能发生冲突，并且迭代器保证不会抛出ConcurrentModificationException。创建迭代器以后，迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作（remove、set和add）不受支持。这些方法将抛出UnsupportedOperationException。允许使用所有元素，包括null。

内存一致性效果：当存在其他并发 collection 时，将对象放入CopyOnWriteArrayList之前的线程中的操作 happen-before 随后通过另一线程从CopyOnWriteArrayList中访问或移除该元素的操作。

这种情况一般在多线程操作时，一个线程对list进行修改。一个线程对list进行fore时会出现java.util.ConcurrentModificationException错误。

下面来看一个列子：两个线程一个线程fore一个线程修改list的值。

 
    01package  com.lucky.concurrent.list;
 
    02 
 
    03import  java.util.ArrayList;
 
    04import  java.util.List;
 
    05import  java.util.concurrent.ExecutorService;
 
    06import  java.util.concurrent.Executors;
 
    07 
 
    08public  class CopyOnWriteArrayListDemo {
 
    09    /**
 
    10     * 读线程
 
    11     * @author wangjie
 
    12     *
 
    13     */
 
    14    private static class  ReadTask implements  Runnable {
 
    15        List<String> list;
 
    16 
 
    17        public ReadTask(List<String> list) {
 
    18            this.list = list;
 
    19        }
 
    20 
 
    21        public void run() {
 
    22            for (String str : list) {
 
    23                System.out.println(str);
 
    24            }
 
    25        }
 
    26    }
 
    27    /**
 
    28     * 写线程
 
    29     * @author wangjie
 
    30     *
 
    31     */
 
    32    private static class  WriteTask implements  Runnable {
 
    33        List<String> list;
 
    34        int index;
 
    35 
 
    36        public WriteTask(List<String> list, int index) {
 
    37            this.list = list;
 
    38            this.index = index;
 
    39        }
 
    40 
 
    41        public void run() {
 
    42            list.remove(index);
 
    43            list.add(index, "write_" + index);
 
    44        }
 
    45    }
 
    46 
 
    47    public void run() {
 
    48        final int NUM = 10;
 
    49        List<String> list = new ArrayList<String>();
 
    50        for (int  i = 0; i < NUM; i++) {
 
    51            list.add("main_" + i);
 
    52        }
 
    53        ExecutorService executorService = Executors.newFixedThreadPool(NUM);
 
    54        for (int  i = 0; i < NUM; i++) {
 
    55            executorService.execute(new ReadTask(list));
 
    56            executorService.execute(new WriteTask(list, i));
 
    57        }
 
    58        executorService.shutdown();
 
    59    }
 
    60 
 
    61    public static void  main(String[] args) {
 
    62        new CopyOnWriteArrayListDemo().run();
 
    63    }
 
    64}

运行结果：

从结果中可以看出来。在多线程情况下报错。其原因就是多线程操作结果：那这个种方案不行我们就换个方案。用jdk自带的类CopyOnWriteArrayList来做容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来然后再尾部add(E)。看源码：

 
    01/**
 
    02    * Appends the specified element to the end of this list.
 
    03    *
 
    04    * @param e element to be appended to this list
 
    05    * @return <tt>true</tt> (as specified by {@link Collection#add})
 
    06    */
 
    07   public boolean add(E e) {
 
    08   final ReentrantLock lock = this.lock;
 
    09   lock.lock();
 
    10   try {
 
    11       Object[] elements = getArray();
 
    12       int len = elements.length;
 
    13       Object[] newElements = Arrays.copyOf(elements, len + 1);
 
    14       newElements[len] = e;
 
    15       setArray(newElements);
 
    16       return true;
 
    17   }  finally {
 
    18       lock.unlock();
 
    19   }
 
    20   }

用到了Arrays.copyOf 方法。这样导致每次操作的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码：

`1`	`// List<String> list = new ArrayList<String>();`

`2`	`CopyOnWriteArrayList<String> list =` `new` `CopyOnWriteArrayList<String>();`

也就把容器list换成了 CopyOnWriteArrayList，其他的没变。线程里面的list不用改。因为 CopyOnWriteArrayList实现的也是list<E> 接口。看结果：

其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。
所以最后得出结论：CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里，比如缓存。发生修改时候做copy，新老版本分离，保证读的高性能，适用于以读为主的情况。