CopyOnWriteArrayList详解

转载 2015年07月07日 13:47:23

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

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

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

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

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

package com.lucky.concurrent.list;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CopyOnWriteArrayListDemo {
    /**
     * 读线程
     * @author wangjie
     *
     */
    private static class ReadTask implements Runnable {
        List<String> list;

        public ReadTask(List<String> list) {
            this.list = list;
        }

        public void run() {
            for (String str : list) {
                System.out.println(str);
            }
        }
    }
    /**
     * 写线程
     * @author wangjie
     *
     */
    private static class WriteTask implements Runnable {
        List<String> list;
        int index;

        public WriteTask(List<String> list, int index) {
            this.list = list;
            this.index = index;
        }

        public void run() {
            list.remove(index);
            list.add(index, "write_" + index);
        }
    }

    public void run() {
        final int NUM = 10;
        List<String> list = new ArrayList<String>();
        for (int i = 0; i < NUM; i++) {
            list.add("main_" + i);
        }
        ExecutorService executorService = Executors.newFixedThreadPool(NUM);
        for (int i = 0; i < NUM; i++) {
            executorService.execute(new ReadTask(list));
            executorService.execute(new WriteTask(list, i));
        }
        executorService.shutdown();
    }

    public static void main(String[] args) {
        new CopyOnWriteArrayListDemo().run();
    }
}

运行结果:

java.util.ConcurrentModificationException
    at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:859)
    at java.util.ArrayList$Itr.next(ArrayList.java:831)
    at com.java.thread.CopyOnWriteArrayListDemo$ReadTask.run(CopyOnWriteArrayListDemo.java:22)
    at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    at java.lang.Thread.run(Thread.java:745)

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

5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

/**
    * Appends the specified element to the end of this list.
    *
    * @param e element to be appended to this list
    * @return <tt>true</tt> (as specified by {@link Collection#add})
    */
   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();
   }
   }

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

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

也就把容器list换成了 CopyOnWriteArrayList,其他的没变。线程里面的list不用改。因为 CopyOnWriteArrayList实现的也是list 接口。就不会报异常了

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

CopyOnWriteArrayList的原理和使用方法

CopyOnWriteArrayList:CopyOnWriteArrayList这是一个ArrayList的线程安全的变体,其原理大概可以通俗的理解为:初始化的时候只有一个容器,很常一段时间,这个容...
  • hua631150873
  • hua631150873
  • 2016年05月03日 16:59
  • 4168

深入Java集合系列之六:CopyOnWriteArrayList

CopyOnWriteArrayList简介CopyOnWriteArrayList容器是Collections.synchronizedList(List list)的替代方案,CopyOnWrit...
  • u011116672
  • u011116672
  • 2016年04月08日 16:18
  • 3245

线程安全的CopyOnWriteArrayList介绍

证明CopyOnWriteArrayList是线程安全的先写一段代码证明CopyOnWriteArrayList确实是线程安全的。ReadThread.javaimport java.util.Lis...
  • linsongbin1
  • linsongbin1
  • 2017年01月17日 16:07
  • 9476

Java并发编程:并发容器之CopyOnWriteArrayList(转载)

跨进程编程时,服务端可能会接受多个客户端的请求进行并发性操作,Aidl文件只支持List中的ArrayList,但在服务端使用CopyOnWriteArrayList(并不是ArrayList的子类,...
  • dongbaoming
  • dongbaoming
  • 2016年11月04日 14:08
  • 756

CopyOnWriteArrayList 并发集合源码分析

在CopyOnWriteArrayList里处理写操作(包括add、remove、set等)是先将原始的数据通过JDK1.6的Arrays.copyof()来生成一份新的数组 然后在新的数据对象上进...
  • likailonghaha
  • likailonghaha
  • 2016年11月30日 11:37
  • 607

【Java并发编程】并发容器之CopyOnWriteArrayList

问题是什么?ArrayList 在使用iterator的时候会遇到ConcurrentModificationException的异常,就是由于遍历的时候,又进行写操作。 解决办法就是:可以通过同步...
  • xude1985
  • xude1985
  • 2016年05月15日 19:45
  • 413

深入Java集合学习系列:CopyOnWriteArrayList详解

http://my.oschina.net/jielucky/blog/167198 http://my.oschina.net/summerpxy/blog/405728 CopyO...
  • lihui6636
  • lihui6636
  • 2015年10月07日 11:07
  • 410

【JAVA集合详解】并发容器之CopyOnWriteArrayList

原文链接:   http://ifeve.com/java-copy-on-write/      Copy-On-Write简称COW,是一种用于程序设计中的优化策略。其基本思路是...
  • qq_1017097573
  • qq_1017097573
  • 2017年07月02日 01:19
  • 173

多线程并发中CopyOnWriteArrayList的使用

除了加锁外,其实还有一种方式可以防止并发修改异常,这就是将读写分离技术(不是数据库上的)。 先回顾一下一个常识: 1、JAVA中“=”操作只是将引用和某个对象关联,假如同时有一个线程将引用指向另外一个...
  • zly_2008
  • zly_2008
  • 2013年08月23日 14:25
  • 389

深入Java集合学习系列:CopyOnWriteArrayList详解

http://my.oschina.net/jielucky/blog/167198http://my.oschina.net/summerpxy/blog/405728CopyOnWriteArra...
  • love_famliy
  • love_famliy
  • 2015年10月13日 17:08
  • 283
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:CopyOnWriteArrayList详解
举报原因:
原因补充:

(最多只允许输入30个字)