java ArrayList vector 线程安全

java ArraList和Vector有什么区别？或许我们都知道的一点是ArrayList是非线程安全的，而Vector是线程安全的。什么是线程安全呢？线程安全就是多个线程对同一个对象进行插入操作时，同一时间段内只有一个线程能够对其进行操作。我们进行一下测试：

使用多个线程同时操作一个ArrayList：

import java.util.ArrayList;
import java.util.concurrent.CountDownLatch;

public class Test{
public static ArrayList<Object> arrayList = new ArrayList<Object>();
public static CountDownLatch countDownLatch = new CountDownLatch(10);
public static int x = 0;
public static void main(String[] args0) throws InterruptedException{
Threads []threads = new Threads[10];
for(int i=0;i<10;i++){
threads[i] = new Threads();
threads[i].start();
}
countDownLatch.await();
for(int i=0;i<arrayList.size();i++){
if(i==(arrayList.size()-1))
System.out.println(arrayList.size());
System.out.println(arrayList.get(i));
}
}
static class Threads extends Thread{
public void run(){
for(int i=0;i<100;i++){
arrayList.add(Thread.currentThread().getName()+"Thread"+x++);
}
countDownLatch.countDown();
}
}
}
其中我们再main函数中创建了一个静态的ArrayList，新建了十个线程，每个线程为ArrayList添加100个元素，并且新建了一个CountDownLatch用于main函数等待线程执行结束。多进行几次测试发现大多数情况下ArrayList的大小并没有1000，有时候还报错

Exception in thread "Thread-0" java.lang.ArrayIndexOutOfBoundsException: 33
at java.util.ArrayList.add(ArrayList.java:459)
at Test$Threads.run(Test.java:24)

这是为什么？     我们看一看ArrayList add方法的源码：
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
其中ensureCapacityInternal 函数函数源码是这样的：
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}

ensureExplicitCapacity(minCapacity);
}
///判断是否可以进行增长
private void ensureExplicitCapacity(int minCapacity) {
modCount++;

// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}

分析上面的两种错误类型：
第一种：   两个线程同时读取错误到了ArrayList的大小，然后进行了更改，更直观的是A线程读取ArrayList的大小为5，线程B读取到的也是5，这样就导致连个线程再同一个位置写入了数据，那么自然就导致了arrayList大小和预期不同。

第二种：   ArrayList越界： 两个（多个）线程同时判断是否需要扩容，发现并不需要。但是当进行插入操作的时候就发现出现了越界。所以报错。

那么Vector是怎么进行线程安全操作的呢？

我们可以从Vector的源码中就可以看出：public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
我们以add的代码为例进行查看:   可以看到和ArrayList的差别就是加上了Synchronized，是这个方法同时只能被一个线程访问：

我们测试一个synchronized方法：

public class Test{
public static void main(String[] args0){
ThreadTemp threadTemp = new ThreadTemp();
Thread thread1 = new Thread(threadTemp);
Thread thread2 = new Thread(threadTemp);
thread1.start();
thread2.start();
}
static class ThreadTemp implements Runnable{
public synchronized void run() {
System.out.println(Thread.currentThread().getName()+"开始执行");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"执行完成");
}
}
}代码中为了保证我们能够让两个线程同时运行一个Runnable实例，我们使用ThreadTemp类实现了Runnable接口，并把run方法改为synchronized的。新建两个Thread类来执行这个类。结果发现执行结果如下：

Thread-0开始执行
Thread-0执行完成
Thread-1开始执行
Thread-1执行完成

只能有一个线程进入此方法区 。这就是synchronized的作用。那么我们现在更改一个上面的代码。使用vector来看看是否还会出现上面的问题。
import java.util.Vector;
import java.util.concurrent.CountDownLatch;

public class Test{
public static Vector<Object> vector = new Vector<Object>();
public static CountDownLatch countDownLatch = new CountDownLatch(10);
public static int x = 0;
public static void main(String[] args0) throws InterruptedException{
Threads []threads = new Threads[10];
for(int i=0;i<10;i++){
threads[i] = new Threads();
threads[i].start();
}
countDownLatch.await();
for(int i=0;i<vector.size();i++){
if(i==(vector.size()-1))
System.out.println(vector.size());
System.out.println(vector.get(i));
}
}
static class Threads extends Thread{
public void run(){
for(int i=0;i<100;i++){
vector.add(Thread.currentThread().getName()+"Thread"+x++);
}
countDownLatch.countDown();
}
}
}

经过多次测试发现并没有发现任何问题。每一次的数据结果都和预期相同。