ArrayList和Vector有什麼區別？HashMap和HashTable有什麼區別？StringBuilder和StringBuffer有什麼區別？這些都是Java面試中常見的基礎問題。面對這樣的問題，回答是：ArrayList是非線程安全的，Vector是線程安全的；HashMap是非線程安全的，HashTable是線程安全的；StringBuilder是非線程安全的，StringBuffer是線程安全的。因爲這是昨晚剛背的《Java面試題大全》上面寫的。此時如果繼續問：什麼是線程安全？線程安全和非線程安全有什麼區別？分別在什麼情況下使用？這樣一連串的問題，一口老血就噴出來了。
非線程安全的現象模擬
這裏就使用ArrayList和Vector二者來說明。
下面的代碼，在主線程中new了一個非線程安全的ArrayList，然後開1000個線程分別向這個ArrayList裏面添加元素，每個線程添加100個元素，等所有線程執行完成後，這個ArrayList的size應該是多少？應該是100000個？
public class Main {
public static void main(String[] args) {
// 進行10次測試
for(int i = 0; i < 10; i++) {
test();
}
}
public static void test() {
// 用來測試的List
List<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的size
System.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次？多跑幾次才能看出問題），輸出結果：
99946
100000
100000
100000
99998
99959
100000
99975
100000
99996上面的輸出結果發現，並不是每次測試結果都是100000，有好幾次測試最後ArrayList的size小於100000。
這就是非線程安全帶來的問題了。上面的代碼如果用於生產環境，就會有隱患就會有BUG了。
再用線程安全的Vector來進行測試，上面代碼改變一處，test()方法中new ArrayList<Object>()改成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，並對他們分別進行了多線程測試。
非線程安全的計數器：
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未進行同步控制，所以非線程安全。
輸出結果：
9963727
9973178
9999577
9987650
9988734
9988665
9987820
9990847
9992305
9972233稍加修改，把Counter改成線程安全的計數器：
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
