标签：comment 面试 inux loaded share ber 部分 公众号 shm
只有光头才能变强
前一阵子写过一篇COW(Copy On Write)文章，结果阅读量很低啊...COW奶牛！Copy On Write机制了解一下
可能大家对这个技术比较陌生吧，但这项技术是挺多应用场景的。除了上文所说的Linux、文件系统外，其实在Java也有其身影。
大家对线程安全容器可能最熟悉的就是ConcurrentHashMap了，因为这个容器经常会在面试的时候考查。
比如说，一个常见的面试场景：
那如果有这样的面试呢？
今天主要讲解的是CopyOnWriteArrayList~
本文力求简单讲清每个知识点，希望大家看完能有所收获
我们知道ArrayList是用于替代Vector的，Vector是线程安全的容器。因为它几乎在每个方法声明处都加了synchronized关键字来使容器安全。
如果使用Collections.synchronizedList(new ArrayList())来使ArrayList变成是线程安全的话，也是几乎都是每个方法都加上synchronized关键字的，只不过它不是加在方法的声明处，而是方法的内部。
在讲解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);
}
复制代码以我们第一反应来分析一下上面两个方法：在多线程环境下，是否有问题？
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);
}
}
复制代码可以发现的是，有可能会抛出异常的：
原因也很简单，我们照着流程走一下就好了：
getLast()方法，线程B执行deleteLast()方法int lastIndex = list.size() - 1;得到lastIndex的值是3。同时，线程B执行int lastIndex = list.size() - 1;得到的lastIndex的值也是3list.remove(lastIndex)将下标为3的元素删除了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的长度，那还是会有问题！
vector.size()时，发现Vector的长度为5clear()操作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是同步List的替代品，CopyOnWriteArraySet是同步Set的替代品。
无论是Hashtable-->ConcurrentHashMap，还是说Vector-->CopyOnWriteArrayList。JUC下支持并发的容器与老一代的线程安全类相比，总结起来就是加锁粒度的问题
所以一般来说，我们都会使用JUC包下给我们提供的线程安全容器，而不是使用老一代的线程安全容器。
下面我们来看看CopyOnWriteArrayList是怎么实现的，为什么使用迭代器遍历的时候就不用额外加锁，也不会抛出ConcurrentModificationException异常。
我们还是先来回顾一下COW：
如果有多个调用者（callers）同时请求相同资源（如内存或磁盘上的数据存储），他们会共同获取相同的指针指向相同的资源，直到某个调用者试图修改资源的内容时，系统才会真正复制一份专用副本（private copy）给该调用者，而其他调用者所见到的最初的资源仍然保持不变。优点是如果调用者没有修改该资源，就不会有副本（private copy）被建立，因此多个调用者只是读取操作时可以共享同一份资源。
参考自维基百科：zh.wikipedia.org/wiki/%E5%AF…
之前写博客的时候，如果是要看源码，一般会翻译一下源码的注释并用图贴在文章上的。Emmm，发现阅读体验并不是很好，所以我这里就直接概括一下源码注释说了什么吧。另外，如果使用IDEA的话，可以下一个插件Translation(免费好用).
概括一下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来完成。
根据上面的分析我们知道如果遍历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()是类似的，这里我就不再贴出代码了。
总结：
常用的方法实现我们已经基本了解了，但还是不知道为啥能够在容器遍历的时候对其进行修改而不抛出异常。所以，来看一下他的迭代器吧：
// 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在使用迭代器遍历的时候，操作的都是原数组！
看了上面的实现源码，我们应该也大概能分析出CopyOnWriteArrayList的缺点了。
add()、set()、remove()的话，那是比较耗费内存的。
add()、set()、remove()这些增删改操作都要复制一个数组出来。setArray()了)。但是线程A迭代出来的是原有的数据。CopyOnWriteArraySet的原理就是CopyOnWriteArrayList。
private final CopyOnWriteArrayList<E> al;
public CopyOnWriteArraySet() {
al = new CopyOnWriteArrayList<E>();
}
复制代码现在临近双十一买阿里云服务器就特别省钱！之前我买学生机也要9.8块钱一个月，现在最低价只需要8.3一个月！
如果有要买服务器的同学可通过我的链接直接享受最低价：m.aliyun.com/act/team111…
阅读这篇文章可能需要对Java容器和多线程有一定的了解。如果对这些知识还不太了解的同学们可看我之前写过的文章哦~
如果大家有更好的理解方式或者文章有错误的地方还请大家不吝在评论区留言，大家互相学习交流~~~
参考资料：
扩展阅读：
一个坚持原创的Java技术公众号：Java3y，欢迎大家关注
3y所有的原创文章：
CopyOnWriteArrayList你都不知道，怎么拿offer？
标签：comment 面试 inux loaded share ber 部分 公众号 shm
原文地址：https://www.cnblogs.com/GarfieldEr007/p/10101768.html
