1. 程式人生 > >線程安全和線程不安全

線程安全和線程不安全

software counter 模擬 tor int bject ase tle 什麽是

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,甚至時不時會拋出個IndexOutOfBoundsException異常。(如果沒有這個現象可以多試幾次)
這就是非線程安全帶來的問題了。上面的代碼如果用於生產環境,就會有隱患就會有BUG了。

再用線程安全的Vector來進行測試,上面代碼改變一處,test()方法中
List<Object> list = new ArrayList<Object>();


改為
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,並對他們分別進行了多線程測試。

非線程安全的計數器:

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

線程安全和線程不安全