Java集合--CopyOnWriteArrayList

ゝ一世哀愁。 2022-06-12 07:49 196阅读 0赞

CopyOnWriteArrayList相当于线程安全的[ArrayList][]。和ArrayList一样，它是个可变数组；但是和ArrayList不同的时，它具有以下特性：  
1. 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。  
2. 它是线程安全的。  
3. 因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。  
4. 迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等操作。

5. 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。

[![03105450-eff31ae9ec034754b19e8e294d701e54.jpg][]][03105450-eff31ae9ec034754b19e8e294d701e54.jpg]

说明：

（1）CopyOnWriteArrayList实现了List接口

（2）CopyOnWriteArrayList实现提供了一个array\[\]数组来存储数据

（3）CopyOnWriteArrayList提供了一个成员ReentrantLock来实现线程安全操作

CopyOnWrite提供的两个变量如下：

（1）互斥锁lock保证线程安全

（2）volatile修饰的变量array保证变量值在所有线程中数据一致

/** The lock protecting all mutators */
        final transient ReentrantLock lock = new ReentrantLock();
    
        /** The array, accessed only via getArray/setArray. */
        private transient volatile Object[] array;

下面从“动态数组”和“线程安全”两个方面进一步对CopyOnWriteArrayList的原理进行说明。

1. CopyOnWriteArrayList的“动态数组”机制 -- 它内部有个“volatile数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile数组”。这就是它叫做CopyOnWriteArrayList的原因！CopyOnWriteArrayList就是通过这种方式实现的动态数组；不过正由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList效率很  
低；但是单单只是进行遍历查找的话，效率比较高。  
2. CopyOnWriteArrayList的“线程安全”机制 -- 是通过volatile和互斥锁来实现的。(01) CopyOnWriteArrayList是通过“volatile数组”来保存数据的。一个线程读取volatile数组时，总能看到其它线程对该volatile变量最后的写入；就这样，通过volatile提供了“读取到的数据总是最新的”这个机制的  
保证。(02) CopyOnWriteArrayList通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile数组”中，然后再“释放互斥锁”；这样，就达到了保护数据的目的。

接下来我们分析一下CopyOnWriteArrayList的add和remove操作来看其具体实现动态数组和线程安全的。

add操作：

（1）在add操作中添加互斥锁lock，保证了线程安全

（2）添加一个数据时，首先将数组长度加一，然后在数组末尾添加元素值。

//通过互斥锁ReentrantLock来保证操作线程安全
    	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();
            }
        }

remove操作：

（1）同样在remove操作中添加互斥锁lock，保证了线程安全

（2）删除数据时会将数组长度减一，然后将剩余的数据添加到新的数组中

//通过互斥锁ReentrantLock来保证操作线程安全
    	  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();
            }
        }

此外CopyOnWriteArrayList提供了一个方法addIfAbsent添加值，如果不存在则添加，如果存在则不添加。

//添加一个值如果不存在则添加，存在则不添加返回false
    	public boolean addIfAbsent(E e) {
            Object[] snapshot = getArray();
            return indexOf(e, snapshot, 0, snapshot.length) >= 0 ? false :
                addIfAbsent(e, snapshot);
        }

[ArrayList]: http://www.cnblogs.com/skywang12345/p/3308556.html
[03105450-eff31ae9ec034754b19e8e294d701e54.jpg]: /images/20220612/1f425b30cdc84d39b25fc26c15e03ab1.png