CopyOnWriteArrayList你都不知道，怎么拿offer？

前言

只有光头才能变强

前一阵子写过一篇cow(copy on write)文章，结果阅读量很低啊...cow奶牛！copy on write机制了解一下

可能大家对这个技术比较陌生吧，但这项技术是挺多应用场景的。除了上文所说的linux、文件系统外，其实在java也有其身影。

大家对线程安全容器可能最熟悉的就是concurrenthashmap了，因为这个容器经常会在面试的时候考查。

比如说，一个常见的面试场景：

• 面试官问：“hashmap是线程安全的吗？如果hashmap线程不安全的话，那有没有安全的map容器”
• 3y：“线程安全的map有两个，一个是hashtable，一个是concurrenthashmap”
• 面试官继续问：“那hashtable和concurrenthashmap有什么区别啊？”
• 3y：“balabalabalabalabalabala"
• 面试官：”ok,ok,ok,看你java基础挺不错的呀“

那如果有这样的面试呢？

• 面试官问：“arraylist是线程安全的吗？如果arraylist线程不安全的话，那有没有安全的类似arraylist的容器”
• 3y：“线程安全的arraylist我们可以使用vector，或者说我们可以使用collections下的方法来包装一下”
• 面试官继续问：“嗯，我相信你也知道vector是一个比较老的容器了，还有没有其他的呢？”
• 3y：“emmmm,这个...“
• 面试官提示：“就比如juc中有concurrenthashmap，那juc中有类似"arraylist"的线程安全容器类吗？“
• 3y：“emmmm,这个...“
• 面试官：”ok,ok,ok,今天的面试时间也差不多了，你回去等通知吧。“

今天主要讲解的是copyonwritearraylist~

本文力求简单讲清每个知识点，希望大家看完能有所收获

一、vector和synchronizedlist

1.1回顾线程安全的vector和synchronizedlist

我们知道arraylist是用于替代vector的，vector是线程安全的容器。因为它几乎在每个方法声明处都加了synchronized关键字来使容器安全。

如果使用collections.synchronizedlist(new arraylist())来使arraylist变成是线程安全的话，也是几乎都是每个方法都加上synchronized关键字的，只不过它不是加在方法的声明处，而是方法的内部。

1.2vector和synchronizedlist可能会出现的问题

在讲解copyonwrite容器之前，我们还是先来看一下线程安全容器的一些可能没有注意到的地方~

下面我们直接来看一下这段代码：

    // 得到vector最后一个元素
    public static object getlast(vector list) {
        int lastindex = list.size() - 1;
        return list.get(lastindex);
    }

    // 删除vector最后一个元素
    public static void deletelast(vector list) {
        int lastindex = list.size() - 1;
        list.remove(lastindex);
    }

以我们第一反应来分析一下上面两个方法：在多线程环境下，是否有问题？

• 我们可以知道的是vector的size()和get()以及remove()都被synchronized修饰的。

答案：从调用者的角度是有问题的

我们可以写段代码测试一下：

import java.util.vector;

public class unsafevectorhelpers {


    public static void main(string[] args) {

        // 初始化vector
        vector<string> vector = new vector();
        vector.add("关注公众号");
        vector.add("java3y");
        vector.add("买linux可到我下面的链接，享受最低价");
        vector.add("给3y加鸡腿");

        new thread(() -> getlast(vector)).start();
        new thread(() -> deletelast(vector)).start();
        new thread(() -> getlast(vector)).start();
        new thread(() -> deletelast(vector)).start();
    }

    // 得到vector最后一个元素
    public static object getlast(vector list) {
        int lastindex = list.size() - 1;
        return list.get(lastindex);
    }

    // 删除vector最后一个元素
    public static void deletelast(vector list) {
        int lastindex = list.size() - 1;
        list.remove(lastindex);
    }
}

可以发现的是，有可能会抛出异常的：

原因也很简单，我们照着流程走一下就好了：

• 线程a执行getlast()方法，线程b执行deletelast()方法
• 线程a执行int lastindex = list.size() - 1;得到lastindex的值是3。同时，线程b执行int lastindex = list.size() - 1;得到的lastindex的值也是3
• 此时线程b先得到cpu执行权，执行list.remove(lastindex)将下标为3的元素删除了
• 接着线程a得到cpu执行权，执行list.get(lastindex);，发现已经没有下标为3的元素，抛出异常了.

出现这个问题的原因也很简单：

• getlast()和deletelast()这两个方法并不是原子性的，即使他们内部的每一步操作是原子性的(被synchronize修饰就可以实现原子性)，但是内部之间还是可以交替执行。
  • 这里的意思就是：size()和get()以及remove()都是原子性的，但是如果并发执行getlast()和deletelast()，方法里面的size()和get()以及remove()是可以交替执行的。

要解决上面这种情况也很简单，因为我们都是对vector进行操作的，只要操作vector前把它锁住就没毛病了！

所以我们可以改成这样子：

    // 得到vector最后一个元素
    public static object getlast(vector list) {
        synchronized (list) {
            int lastindex = list.size() - 1;
            return list.get(lastindex);
        }
    }
    // 删除vector最后一个元素
    public static void deletelast(vector list) {
        synchronized (list) {
            int lastindex = list.size() - 1;
            list.remove(lastindex);
        }
    }

ps:如果有人去测试一下，发现会抛出异常java.lang.arrayindexoutofboundsexception: -1，这是没有检查角标的异常，不是并发导致的问题。

经过上面的例子我们可以看看下面的代码：

    public static void main(string[] args) {

        // 初始化vector
        vector<string> vector = new vector();
        vector.add("关注公众号");
        vector.add("java3y");
        vector.add("买linux可到我下面的链接，享受最低价");
        vector.add("给3y加鸡腿");

        // 遍历vector
        for (int i = 0; i < vector.size(); i++) {

            // 比如在这执行vector.clear();
            //new thread(() -> vector.clear()).start();

            system.out.println(vector.get(i));
        }
    }

同样地：如果在遍历vector的时候，有别的线程修改了vector的长度，那还是会有问题！

• 线程a遍历vector，执行vector.size()时，发现vector的长度为5
• 此时很有可能存在线程b对vector进行clear()操作
• 随后线程a执行vector.get(i)时，抛出异常

在jdk5以后，java推荐使用for-each(迭代器)来遍历我们的集合，好处就是简洁、数组索引的边界值只计算一次。

如果使用for-each(迭代器)来做上面的操作，会抛出concurrentmodificationexception异常

synchronizedlist在使用迭代器遍历的时候同样会有问题的，源码已经提醒我们要手动加锁了。

如果想要完美解决上面所讲的问题，我们可以在遍历前加锁：

		// 遍历vector
 		synchronized (vector) {
            for (int i = 0; i < vector.size(); i++) {
                vector.get(i);
            }
        }

有经验的同学就可以知道：哇，遍历一下容器都要我加上锁，这这这不是要慢死了吗.的确是挺慢的..

所以我们的copyonwritearraylist就登场了！

二、copyonwritearraylist(set)介绍

一般来说，我们会认为：copyonwritearraylist是同步list的替代品，copyonwritearrayset是同步set的替代品。

无论是hashtable-->concurrenthashmap，还是说vector-->copyonwritearraylist。juc下支持并发的容器与老一代的线程安全类相比，总结起来就是加锁粒度的问题

• hashtable、vector加锁的粒度大(直接在方法声明处使用synchronized)
• concurrenthashmap、copyonwritearraylist加锁粒度小(用各种的方式来实现线程安全，比如我们知道的concurrenthashmap用了cas锁、volatile等方式来实现线程安全..)
• juc下的线程安全容器在遍历的时候不会抛出concurrentmodificationexception异常

所以一般来说，我们都会使用juc包下给我们提供的线程安全容器，而不是使用老一代的线程安全容器。

下面我们来看看copyonwritearraylist是怎么实现的，为什么使用迭代器遍历的时候就不用额外加锁，也不会抛出concurrentmodificationexception异常。

2.1copyonwritearraylist实现原理

我们还是先来回顾一下cow：

如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。优点是如果调用者没有修改该资源，就不会有副本（private copy）被建立，因此多个调用者只是读取操作时可以共享同一份资源。

参考自*：https://zh.wikipedia.org/wiki/%e5%af%ab%e5%85%a5%e6%99%82%e8%a4%87%e8%a3%bd

之前写博客的时候，如果是要看源码，一般会翻译一下源码的注释并用图贴在文章上的。emmm，发现阅读体验并不是很好，所以我这里就直接概括一下源码注释说了什么吧。另外，如果使用idea的话，可以下一个插件translation(免费好用).

---

概括一下copyonwritearraylist源码注释介绍了什么：

• copyonwritearraylist是线程安全容器(相对于arraylist)，底层通过复制数组的方式来实现。
• copyonwritearraylist在遍历的使用不会抛出concurrentmodificationexception异常，并且遍历的时候就不用额外加锁
• 元素可以为null

2.1.1看一下copyonwritearraylist基本的结构

    /** 可重入锁对象 */
    final transient reentrantlock lock = new reentrantlock();

    /** copyonwritearraylist底层由数组实现，volatile修饰 */
    private transient volatile object[] array;

    /**
     * 得到数组
     */
    final object[] getarray() {
        return array;
    }

    /**
     * 设置数组
     */
    final void setarray(object[] a) {
        array = a;
    }

    /**
     * 初始化copyonwritearraylist相当于初始化数组
     */
    public copyonwritearraylist() {
        setarray(new object[0]);
    }

看起来挺简单的，copyonwritearraylist底层就是数组，加锁就交由reentrantlock来完成。

2.1.2常见方法的实现

根据上面的分析我们知道如果遍历vector/synchronizedlist是需要自己手动加锁的。

copyonwritearraylist使用迭代器遍历时不需要显示加锁，看看add()、clear()、remove()与get()方法的实现可能就有点眉目了。

首先我们可以看看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;
			
			// 将volatile object[] array 的指向替换成新数组
            setarray(newelements);
            return true;
        } finally {
            lock.unlock();
        }
    }

通过代码我们可以知道：在添加的时候就上锁，并复制一个新数组，增加操作在新数组上完成，将array指向到新数组中，最后解锁。

再来看看size()方法：

	public int size() {

		// 直接得到array数组的长度
        return getarray().length;
    }

再来看看get()方法：

    public e get(int index) {
        return get(getarray(), index);
    }

	final object[] getarray() {
        return array;
    }

那再来看看set()方法

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;
			
			// 将array引用指向新数组
			setarray(newelements);
		} else {
			// not quite a no-op; enssures volatile write semantics
			setarray(elements);
		}
		return oldvalue;
	} finally {
		lock.unlock();
	}
}

对于remove()、clear()跟set()和add()是类似的，这里我就不再贴出代码了。

总结：

• 在修改时，复制出一个新数组，修改的操作在新数组中完成，最后将新数组交由array变量指向。
• 写加锁，读不加锁

2.1.3剖析为什么遍历时不用调用者显式加锁

常用的方法实现我们已经基本了解了，但还是不知道为啥能够在容器遍历的时候对其进行修改而不抛出异常。所以，来看一下他的迭代器吧：

	// 1. 返回的迭代器是cowiterator
	public iterator<e> iterator() {
        return new cowiterator<e>(getarray(), 0);
    }


	// 2. 迭代器的成员属性
    private final object[] snapshot;
    private int cursor;

	// 3. 迭代器的构造方法
	private cowiterator(object[] elements, int initialcursor) {
        cursor = initialcursor;
        snapshot = elements;
    }

	// 4. 迭代器的方法...
	public e next() {
        if (! hasnext())
            throw new nosuchelementexception();
        return (e) snapshot[cursor++];
    }

	//.... 可以发现的是，迭代器所有的操作都基于snapshot数组，而snapshot是传递进来的array数组

到这里，我们应该就可以想明白了！copyonwritearraylist在使用迭代器遍历的时候，操作的都是原数组！

2.1.4copyonwritearraylist缺点

看了上面的实现源码，我们应该也大概能分析出copyonwritearraylist的缺点了。

• 内存占用：如果copyonwritearraylist经常要增删改里面的数据，经常要执行add()、set()、remove()的话，那是比较耗费内存的。
  • 因为我们知道每次add()、set()、remove()这些增删改操作都要复制一个数组出来。
• 数据一致性：copyonwrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。
  • 从上面的例子也可以看出来，比如线程a在迭代copyonwritearraylist容器的数据。线程b在线程a迭代的间隙中将copyonwritearraylist部分的数据修改了(已经调用setarray()了)。但是线程a迭代出来的是原有的数据。

2.1.5copyonwriteset

copyonwritearrayset的原理就是copyonwritearraylist。

    private final copyonwritearraylist<e> al;

    public copyonwritearrayset() {
        al = new copyonwritearraylist<e>();
    }

三、最后

现在临近双十一买阿里云服务器就特别省钱！之前我买学生机也要9.8块钱一个月，现在最低价只需要8.3一个月！

如果有要买服务器的同学可通过我的链接直接享受最低价：https://m.aliyun.com/act/team1111/#/share?params=n.ff7yxcciim.pfn5xpli

---

阅读这篇文章可能需要对java容器和多线程有一定的了解。如果对这些知识还不太了解的同学们可看我之前写过的文章哦~

如果大家有更好的理解方式或者文章有错误的地方还请大家不吝在评论区留言，大家互相学习交流~~~

参考资料：

• 《java并发编程实战》
• 聊聊并发-java中的copy-on-write容器：
• java 中的写时复制 (copy on write, cow)

扩展阅读：

• copyonwritearraylist类set方法疑惑？
• why setarray() method call required in copyonwritearraylist

一个坚持原创的java技术公众号：java3y，欢迎大家关注

3y所有的原创文章：

• 文章的目录导航(脑图+海量视频资源)：https://github.com/zhongfucheng3y/3y