ArrayList和Vector有什么区别？HashMap和HashTable有什么区别？StringBuilder和StringBuffer有什么区别？这些都是Java面试中常见的基础问题面对这样的问题回答是ArrayList是非线程安全的Vector是线程安全的HashMap是非线程安全的HashTable是线程安全的StringBuilder是非线程安全的StringBuffer是线程安全的因为这是昨晚刚背的《Java面试题大全》上面写的此时如果继续问什么是线程安全？线程安全和非线程安全有什么区别？分别在什么情况下使用？这样一连串的问题一口老血就喷出来了…
非线程安全的现象模拟
这里就使用ArrayList和Vector二者来说明
下面的代码在主线程中new了一个非线程安全的ArrayList然后开个线程分别向这个ArrayList里面添加元素每个线程添加个元素等所有线程执行完成后这个ArrayList的size应该是多少？应该是个？
[java]
public class Main
{
public static void main(String[] args)
{
// 进行次测试
for(int i = ; i < ; i++)
{
test();
}
}
public static void test()
{
// 用来测试的List
List<Object> list = new ArrayList<Object>();
// 线程数量()
int threadCount = ;
// 用来让主线程等待threadCount个子线程执行完毕
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
// 启动threadCount个子线程
for(int i = ; i < threadCount; i++)
{
Thread thread = new Thread(new MyThread(list countDownLatch));
threadstart();
}
try
{
// 主线程等待所有子线程执行完成再向下执行
countDownLatchawait();
}
catch (InterruptedException e)
{
eprintStackTrace();
}
// List的size
Systemoutprintln(listsize());
}
}
class MyThread implements Runnable
{
private List<Object> list;
private CountDownLatch countDownLatch;
public MyThread(List<Object> list CountDownLatch countDownLatch)
{
thislist = list;
untDownLatch = countDownLatch;
}
public void run()
{
// 每个线程向List中添加个元素
for(int i = ; i < ; i++)
{
listadd(new Object());
}
// 完成一个子线程
untDown();
}
}
public class Main
{
public static void main(String[] args)
{
// 进行次测试
for(int i = ; i < ; i++)
{
test();
}
}
public static void test()
{
// 用来测试的List
List<Object> list = new ArrayList<Object>();
// 线程数量()
int threadCount = ;
// 用来让主线程等待threadCount个子线程执行完毕
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
// 启动threadCount个子线程
for(int i = ; i < threadCount; i++)
{
Thread thread = new Thread(new MyThread(list countDownLatch));
threadstart();
}
try
{
// 主线程等待所有子线程执行完成再向下执行
countDownLatchawait();
}
catch (InterruptedException e)
{
eprintStackTrace();
}
// List的size
Systemoutprintln(listsize());
}
}
class MyThread implements Runnable
{
private List<Object> list;
private CountDownLatch countDownLatch;
public MyThread(List<Object> list CountDownLatch countDownLatch)
{
thislist = list;
untDownLatch = countDownLatch;
}
public void run()
{
// 每个线程向List中添加个元素
for(int i = ; i < ; i++)
{
listadd(new Object());
}
// 完成一个子线程
untDown();
}
}
上面进行了次测试（为什么要测试次？因为非线程安全并不是每次都会导致问题）
输出结果
上面的输出结果发现并不是每次测试结果都是有好几次测试最后ArrayList的size小于甚至时不时会抛出个IndexOutOfBoundsException异常（如果没有这个现象可以多试几次）
这就是非线程安全带来的问题了上面的代码如果用于生产环境就会有隐患就会有BUG了
再用线程安全的Vector来进行测试上面代码改变一处test()方法中
[java]
List<Object> list = new ArrayList<Object>();
List<Object> list = new ArrayList<Object>();改成
[java]
List<Object> list = new Vector<Object>();
List<Object> list = new Vector<Object>();
再运行程序
输出结果
再多跑几次发现都是没有任何问题因为Vector是线程安全的在多线程操作同一个Vector对象时不会有任何问题
再换成LinkedList试试同样还会出现ArrayList类似的问题因为LinkedList也是非线程安全的
二者如何取捨
非线程安全是指多线程操作同一个对象可能会出现问题而线程安全则是多线程操作同一个对象不会有问题
线程安全必须要使用很多synchronized关键字来同步控制所以必然会导致性能的降低
所以在使用的时候如果是多个线程操作同一个对象那么使用线程安全的Vector否则就使用效率更高的ArrayList
非线程安全!=不安全
有人在使用过程中有一个不正确的观点我的程序是多线程的不能使用ArrayList要使用Vector这样才安全
非线程安全并不是多线程环境下就不能使用注意我上面有说到多线程操作同一个对象注意是同一个对象比如最上面那个模拟就是在主线程中new的一个ArrayList然后多个线程操作同一个ArrayList对象
如果是每个线程中new一个ArrayList而这个ArrayList只在这一个线程中使用那么肯定是没问题的
线程安全的实现
线程安全是通过线程同步控制来实现的也就是synchronized关键字
在这里我用代码分别实现了一个非线程安全的计数器和线程安全的计数器Counter并对他们分别进行了多线程测试
非线程安全的计数器
[java]
public class Main
{
public static void main(String[] args)
{
// 进行次测试
for(int i = ; i < ; i++)
{
test();
}
}
public static void test()
{
// 计数器
Counter counter = new Counter();
// 线程数量()
int threadCount = ;
// 用来让主线程等待threadCount个子线程执行完毕
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
// 启动threadCount个子线程
for(int i = ; i < threadCount; i++)
{
Thread thread = new Thread(new MyThread(counter countDownLatch));
threadstart();
}
try
{
// 主线程等待所有子线程执行完成再向下执行
countDownLatchawait();
}
catch (InterruptedException e)
{
eprintStackTrace();
}
// 计数器的值
Systemoutprintln(countergetCount());
}
}
class MyThread implements Runnable
{
private Counter counter;
private CountDownLatch countDownLatch;
public MyThread(Counter counter CountDownLatch countDownLatch)
{
unter = counter;
untDownLatch = countDownLatch;
}
public void run()
{
// 每个线程向Counter中进行次累加
for(int i = ; i < ; i++)
{
counteraddCount();
}
// 完成一个子线程
untDown();
}
}
class Counter
{
private int count = ;
public int getCount()
{
return count;
}
public void addCount()
{
count++;
}
}
public class Main
{
public static void main(String[] args)
{
// 进行次测试
for(int i = ; i < ; i++)
{
test();
}
}
public static void test()
{
// 计数器
Counter counter = new Counter();
// 线程数量()
int threadCount = ;
// 用来让主线程等待threadCount个子线程执行完毕
CountDownLatch countDownLatch = new CountDownLatch(threadCount);
// 启动threadCount个子线程
for(int i = ; i < threadCount; i++)
{
Thread thread = new Thread(new MyThread(counter countDownLatch));
threadstart();
}
try
{
// 主线程等待所有子线程执行完成再向下执行
countDownLatchawait();
}
catch (InterruptedException e)
{
eprintStackTrace();
}
// 计数器的值
Systemoutprintln(countergetCount());
}
}
class MyThread implements Runnable
{
private Counter counter;
private CountDownLatch countDownLatch;
public MyThread(Counter counter CountDownLatch countDownLatch)
{
unter = counter;
untDownLatch = countDownLatch;
}
public void run()
{
// 每个线程向Counter中进行次累加
for(int i = ; i < ; i++)
{
counteraddCount();
}
// 完成一个子线程
untDown();
}
}
class Counter
{
private int count = ;
public int getCount()
{
return count;
}
public void addCount()
{
count++;
}
}
上面的测试代码中开启个线程每个线程对计数器进行次累加最终输出结果应该是
但是上面代码中的Counter未进行同步控制所以非线程安全
输出结果
稍加修改把Counter改成线程安全的计数器
[java]
class Counter
{
private int count = ;
public int getCount()
{
return count;
}
public synchronized void addCount()
{
count++;
}
}
class Counter
{
private int count = ;
public int getCount()
{
return count;
}
public synchronized void addCount()
{
count++;
}
}
上面只是在addCount()方法中加上了synchronized同步控制就成为一个线程安全的计数器了再执行程序
输出结果
