Java线程安全和非线程安全

ArrayList和Vector有什么区别？

HashMap和HashTable有什么区别？

StringBuilder和StringBuffer有什么区别？

这些都是Java面试中常见的基础问题。面对这样的问题，回答是：ArrayList是非线程安全的，Vector是线程安全的；HashMap是非线程安全的，HashTable是线程安全的；StringBuilder是非线程安全的，StringBuffer是线程安全的。因为这是昨晚刚背的《Java面试题大全》上面写的。此时如果继续问：什么是线程安全？线程安全和非线程安全有什么区别？分别在什么情况下使用？

非线程安全的现象模拟

这里就使用ArrayList和Vector二者来说明。

下面的代码，在主线程中new了一个非线程安全的ArrayList，然后开1000个线程分别向这个ArrayList里面添加元素，每个线程添加100个元素，等所有线程执行完成后，这个ArrayList的size应该是多少？应该是100000个？

[java] view plain copy

print?

1. import java.util.ArrayList;  
2. import java.util.List;  
3. import java.util.concurrent.CountDownLatch;  
4.   
5. public class Main {  
6.     public static void main(String[] args) {  
7.         // 进行10次测试  
8.         for (int i = 0; i < 10; i++) {  
9.             test();  
10.         }  
11.     }  
12.     public static void test() {  
13.         // 用来测试的List  
14.         List<Object> list = new ArrayList<Object>();  
15.   
16.         // 线程数量(1000)  
17.         int threadCount = 1000;  
18.   
19.         // 用来让主线程等待threadCount个子线程执行完毕  
20.         CountDownLatch countDownLatch = new CountDownLatch(threadCount);  
21.   
22.         // 启动threadCount个子线程  
23.         for (int i = 0; i < threadCount; i++) {  
24.             Thread thread = new Thread(new MyThread(list, countDownLatch));  
25.             thread.start();  
26.         }  
27.         try {  
28.             // 主线程等待所有子线程执行完成，再向下执行  
29.             countDownLatch.await();  
30.         } catch (InterruptedException e) {  
31.             e.printStackTrace();  
32.         }  
33.         // List的size  
34.         System.out.println(list.size());  
35.     }  
36. }  
37.   
38. class MyThread implements Runnable {  
39.   
40.     private List<Object> list;  
41.     private CountDownLatch countDownLatch;  
42.   
43.     //构造函数  
44.     public MyThread(List<Object> list, CountDownLatch countDownLatch) {  
45.         this.list = list;  
46.         this.countDownLatch = countDownLatch;  
47.     }  
48.   
49.     public void run() {  
50.         // 每个线程向List中添加100个元素  
51.         for (int i = 0; i < 100; i++) {  
52.             list.add(new Object());  
53.         }  
54.         // 完成一个子线程  
55.         countDownLatch.countDown();  
56.     }  
57. }  

import java.util.ArrayList;import java.util.List;import java.util.concurrent.CountDownLatch;public class Main {public static void main(String[] args) {// 进行10次测试for (int i = 0; i < 10; i++) {test();}}public static void test() {// 用来测试的ListList<Object> list = new ArrayList<Object>();// 线程数量(1000)int threadCount = 1000;// 用来让主线程等待threadCount个子线程执行完毕CountDownLatch countDownLatch = new CountDownLatch(threadCount);// 启动threadCount个子线程for (int i = 0; i < threadCount; i++) {Thread thread = new Thread(new MyThread(list, countDownLatch));thread.start();}try {// 主线程等待所有子线程执行完成，再向下执行countDownLatch.await();} catch (InterruptedException e) {e.printStackTrace();}// List的sizeSystem.out.println(list.size());}}class MyThread implements Runnable {private List<Object> list;private CountDownLatch countDownLatch;//构造函数public MyThread(List<Object> list, CountDownLatch countDownLatch) {this.list = list;this.countDownLatch = countDownLatch;}public void run() {// 每个线程向List中添加100个元素for (int i = 0; i < 100; i++) {list.add(new Object());}// 完成一个子线程countDownLatch.countDown();}}

上面进行了10次测试（为什么要测试10次？因为非线程安全并不是每次都会导致问题）。

输出结果：

99971
99941
99964
99742
99956
100000
99942
99910
99956
99942

上面的输出结果发现，并不是每次测试结果都是100000，有好几次测试最后ArrayList的size小于100000，甚至时不时会抛出个IndexOutOfBoundsException异常。（如果没有这个现象可以多试几次）

这就是非线程安全带来的问题了。上面的代码如果用于生产环境，就会有隐患就会有BUG了。

再用线程安全的Vector来进行测试，上面代码改变一处，test()方法中

[java] view plaincopy

1. List<Object> list = new ArrayList<Object>();  

改成

[java] view plaincopy

1. List<Object> list = new Vector<Object>();  

再运行程序。

输出结果：

100000

100000

100000

100000

100000

100000

100000

100000

100000

100000

再多跑几次，发现都是100000，没有任何问题。因为Vector是线程安全的，在多线程操作同一个Vector对象时，不会有任何问题。

再换成LinkedList试试，同样还会出现ArrayList类似的问题，因为LinkedList也是非线程安全的。

二者如何取舍

非线程安全是指多线程操作同一个对象可能会出现问题。而线程安全则是多线程操作同一个对象不会有问题。

线程安全必须要使用很多synchronized关键字来同步控制，所以必然会导致性能的降低。

所以在使用的时候，如果是多个线程操作同一个对象，那么使用线程安全的Vector；否则，就使用效率更高的ArrayList。

非线程安全!=不安全

有人在使用过程中有一个不正确的观点：我的程序是多线程的，不能使用ArrayList要使用Vector，这样才安全。

非线程安全并不是多线程环境下就不能使用。注意我上面有说到：多线程操作同一个对象。注意是同一个对象。比如最上面那个模拟，就是在主线程中new的一个ArrayList然后多个线程操作同一个ArrayList对象。

如果是每个线程中new一个ArrayList，而这个ArrayList只在这一个线程中使用，那么肯定是没问题的。

线程安全的实现

线程安全是通过线程同步控制来实现的，也就是synchronized关键字。   

在这里，我用代码分别实现了一个非线程安全的计数器和线程安全的计数器Counter，并对他们分别进行了多线程测试。

非线程安全的计数器：

[java] view plain copy

print?

1. import java.util.concurrent.CountDownLatch;  
2.   
3. public class Main {  
4.     public static void main(String[] args) {  
5.         // 进行10次测试  
6.         for (int i = 0; i < 10; i++) {  
7.             test();  
8.         }  
9.     }  
10.     public static void test() {  
11.         // 计数器  
12.         Counter counter = new Counter();  
13.   
14.         // 线程数量(1000)  
15.         int threadCount = 1000;  
16.   
17.         // 用来让主线程等待threadCount个子线程执行完毕  
18.         CountDownLatch countDownLatch = new CountDownLatch(threadCount);  
19.   
20.         // 启动threadCount个子线程  
21.         for (int i = 0; i < threadCount; i++) {  
22.             Thread thread = new Thread(new MyThread(counter, countDownLatch));  
23.             thread.start();  
24.         }  
25.         try {  
26.             // 主线程等待所有子线程执行完成，再向下执行  
27.             countDownLatch.await();  
28.         } catch (InterruptedException e) {  
29.             e.printStackTrace();  
30.         }  
31.         // 计数器的值  
32.         System.out.println(counter.getCount());  
33.     }  
34. }  
35.   
36. class MyThread implements Runnable {  
37.     private Counter counter;  
38.     private CountDownLatch countDownLatch;  
39.   
40.     //构造函数  
41.     public MyThread(Counter counter, CountDownLatch countDownLatch) {  
42.         this.counter = counter;  
43.         this.countDownLatch = countDownLatch;  
44.     }  
45.   
46.     public void run() {  
47.         // 每个线程向Counter中进行10000次累加  
48.         for (int i = 0; i < 10000; i++) {  
49.             counter.addCount();  
50.         }  
51.         // 完成一个子线程  
52.         countDownLatch.countDown();  
53.     }  
54. }  
55.   
56. class Counter {  
57.     private int count = 0;  
58.     public int getCount() {  
59.         return count;  
60.     }  
61.     public void addCount() {  
62.         count++;  
63.     }  
64. }  

import java.util.concurrent.CountDownLatch;public class Main {public static void main(String[] args) {// 进行10次测试for (int i = 0; i < 10; i++) {test();}}public static void test() {// 计数器Counter counter = new Counter();// 线程数量(1000)int threadCount = 1000;// 用来让主线程等待threadCount个子线程执行完毕CountDownLatch countDownLatch = new CountDownLatch(threadCount);// 启动threadCount个子线程for (int i = 0; i < threadCount; i++) {Thread thread = new Thread(new MyThread(counter, countDownLatch));thread.start();}try {// 主线程等待所有子线程执行完成，再向下执行countDownLatch.await();} catch (InterruptedException e) {e.printStackTrace();}// 计数器的值System.out.println(counter.getCount());}}class MyThread implements Runnable {private Counter counter;private CountDownLatch countDownLatch;//构造函数public MyThread(Counter counter, CountDownLatch countDownLatch) {this.counter = counter;this.countDownLatch = countDownLatch;}public void run() {// 每个线程向Counter中进行10000次累加for (int i = 0; i < 10000; i++) {counter.addCount();}// 完成一个子线程countDownLatch.countDown();}}class Counter {private int count = 0;public int getCount() {return count;}public void addCount() {count++;}}

上面的测试代码中，开启1000个线程，每个线程对计数器进行10000次累加，最终输出结果应该是10000000。

但是上面代码中的Counter未进行同步控制，所以非线程安全。

输出结果：

9950062
9853809
9833797
9765142
9764742
9816807
9817050
9797221
9516303
9189680
稍加修改，把Counter改成线程安全的计数器（执行过程明显慢了很多。。。）：

[java] view plain copy

print?

1. class Counter{  
2.     private int count = 0;  
3.   
4.     public int getCount(){  
5.         return count;  
6.     }  
7.   
8.     public synchronized void addCount(){  
9.         count++;  
10.     }  
11. }  

class Counter{private int count = 0;public int getCount(){return count;}public synchronized void addCount(){count++;}}

上面只是在addCount()方法中加上了synchronized同步控制，就成为一个线程安全的计数器了。再执行程序。

输出结果：

10000000

10000000

10000000

10000000

10000000

10000000

10000000

10000000

10000000

10000000

作者：叉叉哥   转载请注明出处：http://blog.csdn.net/xiao__gui/article/details/8934832