Java集合-CopyOnWriteArrayList源码解析-JDK1.8

分手后的思念是犯贱 2024-04-18 20:25 80阅读 0赞

◆

CopyOnWriteArrayList简介

◆

CopyOnWriteArrayList和ArrayList一样是一个动态数组。而与ArrayList不同的是，它是线程安全的。

建议先阅读 [ArrayList源码分析][ArrayList] ，再回来看此文会Soeasy哦！

CopyOnWriteArrayList实现了List, RandomAccess, Cloneable, java.io.Serializable这些接口。

1.  List提供了添加、删除、修改、遍历等功能。
2.  RandmoAccess提供了随机访问功能
3.  Cloneable提供了可以被克隆的功能
4.  Serializable提供了序列化的功能

◆

CopyOnWriteArrayList的属性

◆

/**实现线程安全的锁对象*/	
        final transient ReentrantLock lock = new ReentrantLock();	
    
    	
        /** 元素缓冲区，volatile保证多线程下始终读取到最新的数据*/	
        private transient volatile Object[] array;

上方的lock对象就是CopyOnWriteArrayList实现线程安全的秘诀。

对于Java中的锁有疑问的同学可以参考此文章：  [Java中的锁][Java]

◆

CopyOnWriteArrayList的构造方法

◆

public CopyOnWriteArrayList() {	
            setArray(new Object[0]);	
        }	
    
    	
    
    	
        public CopyOnWriteArrayList(Collection<? extends E> c) {	
            Object[] elements;	
            if (c.getClass() == java.util.concurrent.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);	
        }	
    
    	
        public CopyOnWriteArrayList(E[] toCopyIn) {	
            setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));	
        }	
        final void setArray(Object[] a) {	
            array = a;	
        }

三个构造方法最后都是调用的setArray方法完成的初始化。

◆

CopyOnWriteArrayList的方法

◆

接下来我们就以CopyOnWriteArrayList的几个比较经典的方法来看一下它是如何设计的。

首先是添加方法：

/**	
         * 添加	
         */	
        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();	
            }	
        }	
    
    	
        /**	
         * 指定索引添加	
         */	
        public void add(int index, E element) {	
            final ReentrantLock lock = this.lock;	
            lock.lock();	
            try {	
                Object[] elements = getArray();	
                int len = elements.length;	
                if (index > len || index < 0)	
                    throw new IndexOutOfBoundsException("Index: "+index+	
                            ", Size: "+len);	
                Object[] newElements;	
                int numMoved = len - index;	
                if (numMoved == 0)	
                    newElements = Arrays.copyOf(elements, len + 1);	
                else {	
                    newElements = new Object[len + 1];	
                    System.arraycopy(elements, 0, newElements, 0, index);	
                    System.arraycopy(elements, index, newElements, index + 1,	
                            numMoved);	
                }	
                newElements[index] = element;	
                setArray(newElements);	
            } finally {	
                lock.unlock();	
            }	
        }	
        final Object[] getArray() {	
            return array;	
        }	
        final void setArray(Object[] a) {	
            array = a;	
        }

可以看的，进行添加之前首先是要先获得锁对象才继续进行的操作（包括修改和删除），只有这样才能保证线程安全。

接着看添加的逻辑

新建一个数组，接着将通过getArray（）方法获取到的原始的数组拷贝到新数组中，然后将新增数据也添加到新数组中；最后将新数组赋值给原先的数组。

接下来看删除操作：

/**	
         * 删除	
         */	
        public E remove(int index) {	
            final ReentrantLock lock = this.lock;	
            lock.lock();	
            try {	
                Object[] elements = getArray();	
                int len = elements.length;	
                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();	
            }	
        }

同添加方法相同的逻辑，先获取锁，然后通过copy数组方式进行删除操作。

接下来修改方法，修改的时候也使用到了查询方法：

/**	
         * 替换指定索引的元素	
         */	
        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;	
                    setArray(newElements);	
                } else {	
                    // Not quite a no-op; ensures volatile write semantics	
                    setArray(elements);	
                }	
                return oldValue;	
            } finally {	
                lock.unlock();	
            }	
        }	
         /**	
         * get方法	
         */	
        public E get(int index) {	
            return get(getArray(), index);	
        }	
         @SuppressWarnings("unchecked")	
        private E get(Object[] a, int index) {	
            return (E) a[index];	
        }

第一步同样是加锁，接着会有一个判断，看要修改的索引位置的元素是否相同，不相同则继续通过copy数组的方式进行替换，最后使用setArray()方法更新。

**看了CopyOnWriteArrayList的增删改查方法你就应该明白一件事，这哥们除了查询、增删改都很慢呀。**

与ArrayList相比，CopyOnWriteArrayList最值得我们注意的地方就是：

1.  增删改操作必须获取锁之后才能进行，操作完毕释放锁其他操作才可以继续执行
2.  get元素是使用volatile修饰的，可以保证多线程之间的数据更新同步

鉴于篇幅有限，本篇文章仅列出上方部分代码，CopyOnWriteArrayList完整源码解析请 点击下方“阅读原文”查看！！！

![640?wx\_fmt=gif][640_wx_fmt_gif]

不得不看

1.[SpringCloud系列博客汇总][SpringCloud]

2.[Java多线程面试必备基础知识汇总][Java 1]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

万水千山总是情，点个 “在看” 行不行！！！

![640?wx\_fmt=png][640_wx_fmt_png]

[ArrayList]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247484016&idx=1&sn=c0580740e925f0bd9a0654ace07d628a&chksm=fe39684ec94ee1585a3cefb6776ea0bb1a2aeab7787afbbeee86baf4198733ab0a8ce57f427e&scene=21#wechat_redirect
[Java]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247483974&idx=1&sn=c2ea0f9bb39490dbe6fb10ac605214ce&chksm=fe396878c94ee16eea12fa691c878e74fdbd0060eda999475d927a998fbf3fe974b92e8a1a10&scene=21#wechat_redirect
[640_wx_fmt_gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/a73c4e1d7339472985d0491e34ed3567.gif
[SpringCloud]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247484030&idx=1&sn=7ad29239aca876e29155f5b1439281bb&chksm=fe396840c94ee156adfcd44c63a3b5c1cf93805cf592ad7d45bc5222c349ba6f552b553a5c09&scene=21#wechat_redirect
[Java 1]: http://mp.weixin.qq.com/s?__biz=MzU5MDgzOTYzMw==&mid=2247484030&idx=2&sn=ddf120fcbfc45238e64662fd183156de&chksm=fe396840c94ee156a80b744033ac34d67e331545193d2f9d4f2943995aa4412a53fec023d599&scene=21#wechat_redirect
[640_wx_fmt_jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/3cece05d896d44a78747e0d93e69258a.png
[640_wx_fmt_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/387c8fe0c68b4bc4b4436a7e2243510f.png