JAVA中的線程安全與非線程安全

時間 2019-11-12

標籤 java 線程安全欄目 Java 简体版

原文原文鏈接

就是線程同步的意思，就是當一個程序對一個線程安全的方法或者語句進行訪問的時候，其餘的不能再對他進行操做了，必須等到此次訪問結束之後才能對這個線程安全的方法進行訪問
什麼叫線程安全：
若是你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。若是每次運行結果和單線程運行的結果是同樣的，並且其餘的變量的值也和預期的是同樣的，
就是線程安全的。
或者說:一個類或者程序所提供的接口對於線程來講是原子操做或者多個線程之間的切換不會致使該接口的執行結果存在二義性,也就是說咱們不用考慮同步的問題。
線程安全問題都是由全局變量及靜態變量引發的。
若每一個線程中對全局變量、靜態變量只有讀操做，而無寫操做，通常來講，這個全局變量是線程安全的；如有多個線程同時執行寫操做，通常都須要考慮線程同步，不然就可能影響線程安全。

存在競爭的線程不安全，不存在競爭的線程就是安全的面試

轉自http://blog.csdn.net/xiao__gui/article/details/8934832安全

線程安全就是多線程訪問時，採用了加鎖機制，當一個線程訪問該類的某個數據時，進行保護，其餘線程不能進行訪問直到該線程讀取完，其餘線程纔可以使用。不會出現數據不一致或者數據污染。markdown

線程不安全就是不提供數據訪問保護，有可能出現多個線程前後更改數據形成所獲得的數據是髒數據多線程

ArrayList和Vector有什麼區別？HashMap和HashTable有什麼區別？StringBuilder和StringBuffer有什麼區別？這些都是Java面試中常見的基礎問題。面對這樣的問題，回答是：ArrayList是非線程安全的，Vector是線程安全的；HashMap是非線程安全的，HashTable是線程安全的；StringBuilder是非線程安全的，StringBuffer是線程安全的。由於這是昨晚剛背的《Java面試題大全》上面寫的。此時若是繼續問：什麼是線程安全？線程安全和非線程安全有什麼區別？分別在什麼狀況下使用？這樣一連串的問題，一口老血就噴出來了…post

非線程安全的現象模擬性能

這裏就使用ArrayList和Vector兩者來講明。測試

下面的代碼，在主線程中new了一個非線程安全的ArrayList，而後開1000個線程分別向這個ArrayList裏面添加元素，每一個線程添加100個元素，等全部線程執行完成後，這個ArrayList的size應該是多少？應該是100000個？ui

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次？由於非線程安全並非每次都會致使問題）。
輸出結果：this

99946spa

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，沒有任何問題。由於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