package 第二章.并发下的ArrayList;
import java.util.ArrayList;
import java.util.List;
/**
* Created by zzq on 2018/1/19.
*/
public class 并发下的ArrayList {
static ArrayList<Integer> list=new ArrayList<Integer>();
public static class AddThread extends Thread{
@Override
public void run() {
for (int i = 0; i < 100000; i++) {
list.add(i);
}
}
}
public static void main(String[] args) throws InterruptedException {
//ArrayList 网上介绍有容量上限 大约8GB左右
//扩容的公式 ((旧容量 * 3) / 2) + 1 注：这点与C#语言是不同的，C#当中的算法很简单，是翻倍。
/* 一旦容量发生变化，就要带来额外的内存开销，和时间上的开销。
所以，在已经知道容量大小的情况下，推荐使用下面方式进行声明：
List arrayList = new ArrayList(CAPACITY_SIZE);
即指定默认容量大小的方式。
*/
Thread t1=new Thread(new AddThread());
Thread t2=new Thread(new AddThread());
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println(list.size());
/*上面的程序经过我多次测试得出3个结果
1：size为200000（理想情况）
2：size为小于200000（多次） 因为ArrayList 是一个线程不安全的容器
3：会报异常（这是由于ArrayList在扩容的时候，内部一致性被破坏了，由于没有所的保护，
另一个线程访问到了不一致的背部状态，导致越界问题）
Exception in thread "Thread-3" java.lang.ArrayIndexOutOfBoundsException: 2776
at java.util.ArrayList.add(ArrayList.java:441)
at 第二章.程序的幽灵之隐蔽的错误.并发下的ArrayList$AddThread.run(并发下的ArrayList.java:15)
at java.lang.Thread.run(Thread.java:745)
*/
}
}
1.ArrayListde add()方法：（源码分析）
public boolean add(E e) {
@ 备注1： ensureCapacityInternal(size + 1); //
@ 备注2： elementData[size++] = e;
return true;
}
@ 备注1：解析 其中 ensureCapacityInternal（size + 1）方法是 比较当前list的长度和该list的容量，我们进入该方法继续观看
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {//判断该list的容量 是否为空，如果为空，给它一个默认的值 10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
其中 ensureExplicitCapacity(minCapacity) 方法的作用 是判断改list是否需要扩容：我们进入该方法中查看：
private void ensureExplicitCapacity(int minCapacity) {
modCount++;//位置加1
// overflow-conscious code
if (minCapacity - elementData.length > 0) //如果当前的size大于此刻list的容量，那么就进行扩容。
grow(minCapacity);
}
其中 grow(minCapacity) 方法为扩容方法（请看源码）：
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//容量为原来的1.5倍
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);//将此刻的list拷贝到一个新的扩容之后list中
}
@ 备注2：经过以上的判断，然后 elementData[size++] = e; 将该元素加入到该list中
线程安全问题：
通过以上的分析，我们就知道，如果单线程中，是串行的，后面的操作是在之前的操作结束后再次执行，所以list的每一次add方法后都能保持list数据结构的一致
但是在多线程中：没有用到锁机制的前提下线程之间是并行的，那么我们开始分析2种错误形式：（以我们的测试案例来说明）
第一种：size为小于200000（多次）
在 @ 备注1的操作时候2个线程同时拿到一个位置，然后添加，这就会造成 实际是添加2条数据，但是由于 index值是一样的，那么我们实际存入的是一条
第二种：会报异常（数组越界）
发生这种情况，是因为2个线程同时拿到了最后一个位置，但是他们都认为这是最后一个位置，所以list没有进行扩容，所以在其中一个线程执行 @ 备注2 之后，另一个线程也执行了 @ 备注2
这就造成了，本来list的size为10，第二个线程添加的位置是11，所以就会报出 数组越界