并发下的ArrayList
那么它究竟会出现什么问题呢？我们写一段简单的代码看一下：
这段代码中，我们创建了两个线程，同时对ArrayList添加10000个元素，如果我们运行这段代码，我们肯定期望它返回的是100000。可是我在JDK1.8环境中运行这段代码，多次验证，会出现两种结果：
import java.util.*;
import java.util.concurrent.CopyOnWriteArrayList;
public class T02_CopyOnWriteList {
public static void main(String[] args) {
List<String> lists =
new ArrayList<>(); //这个会出并发问题！
//new Vector();
//new CopyOnWriteArrayList<>();
/* List<String> strs = new ArrayList<>();
List<String> lists = Collections.synchronizedList(strs);*/
Random r = new Random();
Thread[] ths = new Thread[100];
for(int i=0; i<ths.length; i++) {
Runnable task = new Runnable() {
@Override
public void run() {
for(int i=0; i<1000; i++) lists.add("a" + r.nextInt(10000));
}
};
ths[i] = new Thread(task);
}
runAndComputeTime(ths);
System.out.println(lists.size());
}
static void runAndComputeTime(Thread[] ths) {
long s1 = System.currentTimeMillis();
Arrays.asList(ths).forEach(t->t.start());
Arrays.asList(ths).forEach(t->{
try {
t.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
});
long s2 = System.currentTimeMillis();
System.out.println(s2 - s1);
}
}
从以上的实验中可以得出，除了 ArrayList，其它集合在多线程的情况下都是线程安全的
第一种：抛出数组越界异常
Exception in thread "Thread-4" java.lang.ArrayIndexOutOfBoundsException: 163
at java.util.ArrayList.add(ArrayList.java:459)
at com.mashibing.juc.c_025.T02_CopyOnWriteList$1.run(T02_CopyOnWriteList.java:31)
at java.lang.Thread.run(Thread.java:748)
Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 1851
at java.util.ArrayList.add(ArrayList.java:459)
at com.mashibing.juc.c_025.T02_CopyOnWriteList$1.run(T02_CopyOnWriteList.java:31)
at java.lang.Thread.run(Thread.java:748)第二种：集合长度不到10万
这是为什么呢？我们来看看ArrayList的部分源码：
//存放list集合元素的数组,默认容量10
transient Object[] elementData;
//list大小
private int size;我们再来看看add源码:
public boolean add(E e) {
//确定添加元素之后，集合的大小是否足够，若不够则会进行扩容
ensureCapacityInternal(size + 1); // Increments modCount!!
//插入元素
elementData[size++] = e;
return true;
}现在我们假如有两个线程在对list插入值，这时线程A获取到的size大小为9，线程B获取的size大小也为9，但是线程A在执行完ensureCapacityInternal(size + 1)后时间片用完了，线程B得以执行，这时线程B发现size+1=10，刚好满足容量大小，不需要进行扩容，这时线程A得到时间片，这时它来执行 elementData[size++] = e时，然而现在size大小为10，这时进行插入就会出现数组越界情况。另外，我们发现size字段没有使用volatile修饰，size++本身就是非原子性的，多个线程之间访问冲突，这时两个线程可能对同一个位置赋值，就可能出现size小于期望值的结果。
synchronizedList()&CopyOnWriteArrayList
在实际项目中，List是我们使用非常频繁的容器，那么如果在并发环境中，我们怎么获取到线程安全的List容器呢？ 相信大家都知道Collections这样的一个类，使用它我们可以获取线程安全的List容器—Collections.synchronizedList(List<T> list)，但是无论是读取还是写入，它都会进行加锁，当我们并发级别特别高，线程之间在任何操作上都会进行等待，因此在某些场景中它不是最好的选择。在很多的场景中，我们的读取操作可能远远大于写入操作，这时使用这种方式，显然不能让我们满意，那么怎么办呢？别担心，JDK已经为我们考虑好了，为了将读取的性能发挥到极致，提供了CopyOnWriteArrayList类，该类在使用过程中，读读之间不互斥并且更厉害的是读写也不互斥。下面，我们来看看它如何做到的：
public boolean add(E e) {
//获取重入锁
final ReentrantLock lock = this.lock;
//加锁
lock.lock();
try {
//得到旧数组并获取旧数组的长度
Object[] elements = getArray();
int len = elements.length;
//复制旧数组的元素到新的数组中并且大小在原基础上加1
Object[] newElements = Arrays.copyOf(elements, len + 1);
//把值插入到新数组中
newElements[len] = e;
//使用新数组替换老数组
setArray(newElements);
return true;
} finally {
//释放锁
lock.unlock();
}
}从源码中，我们可以看出add操作中使用了重入锁，但是此锁只针对写-写操作。为什么读写之间不用互斥，关键就在于添加值的操作并不是直接在原有数组中完成，而是使用原有数组复制一个新的数组，然后将值插入到新的数组中，最后使用新数组替换旧数组，这样插入就完成了。大家可以发现，使用这种方式，在add的过程中旧数组没有得到修改，因此写入操作不影响读取操，另外，数组定义private transient volatile Object[] array，其中采用volatile修饰，保证内存可见性，读取线程可以马上知道这个修改。下面我们来看看读取的操作：
public E get(int index) {
return get(getArray(), index);
}
private E get(Object[] a, int index) {
return (E) a[index];
}
final Object[] getArray() {
return array;
}读取操作完全没有使用任何的同步控制或者是加锁，这是因为array数组内部结构不会发生任何改变，只会被另外一个array所替换，因此读取是线程安全的。
大家可以使用上面描述的两种方式，来测试结果是否和我们预期的一样。另外关于这两种方式，大家可以测一测它们在读多写少和写多读少情况下的性能有何不同。
总结
在JDK中，获取线程安全的List，我们可以使用Collections.synchronizedList(List<T> list)方式，也可以使用CopyOnWriteArrayList类。
在真实环境中，使用它们可以根据我们的业务需要，在插入操作远远超过读取时，建议使用synchronizedList，这是因为CopyOnWriteArrayList在插入的过程中会创建新的数组，这样在数据量特别大的情况下，对内存的消耗是很大的。当然，如果是读取操作远远大于插入时，第二种方式肯定更占优势，毕竟读取操作完全不需要加锁
一句话：读多写少： 用CopyOnWriteArrayList
写多读少: 用synchronizedList
当然最终哪个快还是以实际压测结果为准