线程安全的CopyOnWriteArrayList介绍

证实CopyOnWriteArrayList是线程安全的

先写一段代码证实CopyOnWriteArrayList确实是线程安全的。

ReadThread.java

import java.util.List;

public class ReadThread implements Runnable {
    private List<Integer> list;

    public ReadThread(List<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        for (Integer ele : list) {
            System.out.println("ReadThread:"+ele);
        }
    }
}

WriteThread.java

import java.util.List;

public class WriteThread implements Runnable {
    private List<Integer> list;

    public WriteThread(List<Integer> list) {
        this.list = list;
    }

    @Override
    public void run() {
        this.list.add(9);
    }
}

测试程序：TestCopyOnWriteArrayList.java

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestCopyOnWriteArrayList {

    private void test() {
        //一、初始化CopyOnWriteArrayList
        List<Integer> tempList = Arrays.asList(new Integer [] {1,2});
        CopyOnWriteArrayList<Integer> copyList = new CopyOnWriteArrayList<>(tempList);


        //二、模拟多线程对list进行读和写
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new ReadThread(copyList));
        executorService.execute(new WriteThread(copyList));
        executorService.execute(new WriteThread(copyList));
        executorService.execute(new WriteThread(copyList));
        executorService.execute(new ReadThread(copyList));
        executorService.execute(new WriteThread(copyList));
        executorService.execute(new ReadThread(copyList));
        executorService.execute(new WriteThread(copyList));

        System.out.println("copyList size:"+copyList.size());
    }


    public static void main(String[] args) {
        new TestCopyOnWriteArrayList().test();
    }
}

运行上面的代码,没有报出

java.util.ConcurrentModificationException

说明了CopyOnWriteArrayList并发多线程的环境下，仍然能很好的工做。

CopyOnWriteArrayList如何作到线程安全的

CopyOnWriteArrayList使用了一种叫写时复制的方法，当有新元素添加到CopyOnWriteArrayList时，先从原有的数组中拷贝一份出来，而后在新的数组作写操做，写完以后，再将原来的数组引用指向到新数组。

当有新元素加入的时候，以下图，建立新数组，并往新数组中加入一个新元素,这个时候，array这个引用仍然是指向原数组的。

当元素在新数组添加成功后，将array这个引用指向新数组。

CopyOnWriteArrayList的整个add操做都是在锁的保护下进行的。 这样作是为了不在多线程并发add的时候，复制出多个副本出来,把数据搞乱了，致使最终的数组数据不是咱们指望的。

CopyOnWriteArrayList的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;
        //四、将array引用指向到新数组
        setArray(newElements);
        return true;
    } finally {
       //五、解锁
        lock.unlock();
    }
}

因为全部的写操做都是在新数组进行的，这个时候若是有线程并发的写，则经过锁来控制，若是有线程并发的读，则分几种状况：

• 一、若是写操做未完成，那么直接读取原数组的数据；
• 二、若是写操做完成，可是引用还未指向新数组，那么也是读取原数组数据；
• 三、若是写操做完成，而且引用已经指向了新的数组，那么直接重新数组中读取数据。

可见，CopyOnWriteArrayList的读操做是能够不用加锁的。

CopyOnWriteArrayList的使用场景

经过上面的分析，CopyOnWriteArrayList 有几个缺点：

• 一、因为写操做的时候，须要拷贝数组，会消耗内存，若是原数组的内容比较多的状况下，可能致使young gc或者full gc
• 二、不能用于实时读的场景，像拷贝数组、新增元素都须要时间，因此调用一个set操做后，读取到数据可能仍是旧的,虽然CopyOnWriteArrayList 能作到最终一致性,可是仍是无法知足实时性要求；

CopyOnWriteArrayList 合适读多写少的场景，不过这类慎用

由于谁也无法保证CopyOnWriteArrayList 到底要放置多少数据，万一数据稍微有点多，每次add/set都要从新复制数组，这个代价实在过高昂了。在高性能的互联网应用中，这种操做分分钟引发故障。

#CopyOnWriteArrayList透露的思想 如上面的分析CopyOnWriteArrayList表达的一些思想：

• 一、读写分离，读和写分开
• 二、最终一致性
• 三、使用另外开辟空间的思路，来解决并发冲突