Java面试题总结(4)之线程安全的CopyOnWriteArrayList介绍

约定不等于承诺〃 2023-06-27 05:51 21阅读 0赞

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

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

测试代码：

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

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() {
            //1、初始化CopyOnWriteArrayList
            List<Integer> tempList = Arrays.asList(new Integer [] {1,2});
            CopyOnWriteArrayList<Integer> copyList = new CopyOnWriteArrayList<>(tempList);
    
    
            //2、模拟多线程对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这个引用仍然是指向原数组的。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70 1][]

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

`CopyOnWriteArrayList`的`add`操作的源代码如下：

public boolean add(E e) {
        //1、先加锁
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            Object[] elements = getArray();
            int len = elements.length;
            //2、拷贝数组
            Object[] newElements = Arrays.copyOf(elements, len + 1);
            //3、将元素加入到新数组中
            newElements[len] = e;
            //4、将array引用指向到新数组
            setArray(newElements);
            return true;
        } finally {
           //5、解锁
            lock.unlock();
        }
    }

由于所有的写操作都是在新数组进行的，这个时候如果有线程并发的写，则通过锁来控制，如果有线程并发的读，则分几种情况：

*  如果写操作未完成，那么直接读取原数组的数据；
 *  如果写操作完成，但是引用还未指向新数组，那么也是读取原数组数据； 
 *  如果写操作完成，并且引用已经指向了新的数组，那么直接从新数组中读取数据。

可见，`CopyOnWriteArrayList`的**读操作**是可以不用**加锁**的。

*  **CopyOnWriteArrayList的使用场景**

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

*  由于写操作的时候，需要拷贝数组，会消耗内存，如果原数组的内容比较多的情况下，可能导致`young gc`或者`full gc`
 *  不能用于**实时读**的场景，像拷贝数组、新增元素都需要时间，所以调用一个`set`操作后，读取到数据可能还是旧的,虽然`CopyOnWriteArrayList` 能做到**最终一致性**,但是还是没法满足实时性要求；
 *  `CopyOnWriteArrayList` 合适**读多写少**的场景，不过这类慎用 ，因为谁也没法保证`CopyOnWriteArrayList` 到底要放置多少数据，万一数据稍微有点多，每次add/set都要重新复制数组，这个代价实在太高昂了。在高性能的互联网应用中，这种操作分分钟引起故障。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200103231051340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020010323202833.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2pva2VNcWM=,size_16,color_FFFFFF,t_70