java線程安全問題之靜態成員變量、實例成員變量、局部變量

java多線程編程中，存在很多線程安全問題，至於什麼是線程安全呢，給出一個通俗易懂的概念還是蠻難的，如同《java併發編程實踐》中所說：

寫道

給線程安全下定義比較困難。存在很多種定義，如：“一個類在可以被多個線程安全調用時就是線程安全的”。

此處不贅述了，首先給出靜態變量、實例變量、局部變量在多線程環境下的線程安全問題結論，然後用示例驗證，請大家擦亮眼睛，有錯必究，否則誤人子弟！

靜態成員變量：線程非安全（無論單例或者非單例皆不安全）。

靜態變量即類變量，位於方法區，爲所有對象共享，共享一份內存，一旦靜態變量被修改，其他對象均對修改可見，故線程非安全。

實例成員變量：單例模式（只有一個對象實例singleton存在）線程非安全，非單例線程安全。

實例變量爲對象實例私有，在虛擬機的堆heap中分配，若在系統中只存在一個此對象的實例，在多線程環境下，“猶如”靜態變量那樣，被某個線程修改後，其他線程對修改均可見，故線程非安全（如，springmvc controller是單例的，非線程安全的）；如果每個線程執行都是在不同的對象中，那對象與對象之間的實例變量的修改將互不影響，故線程安全（如，struts2 action默認是非單例的，每次請求在heap中new新的action實例，故struts2 action可以用實例成員變量）。

局部變量：線程安全（線程封閉性Thread Confinement）。

每個線程執行時將會把局部變量放在各自棧幀的工作內存中，線程間不共享，故不存在線程安全問題。

〖by self：上述所有的變量均指，共享的（Shared）和可變的（Mutable，進行了'read''write'操作）狀態變量，只有對這樣的變量討論線程安全才有意義，所有實際上上述的“局部變量”一定是線程安全的，因爲其不是共享的（Not Shared），至於非狀態變量，毫無疑問，是線程安全的。〗

靜態成員變量 線程安全問題模擬：

----------------------------------------------------------------------------------

/**
  * 線程安全問題模擬執行
  *  ------------------------------
  *       線程1      |    線程2
  *  ------------------------------
  *   static_i = 4;  | 等待
  *   static_i = 10; | 等待
  *    等待          | static_i = 4;
  *   static_i * 2;  | 等待
  *  -----------------------------
 * */
public class Test implements Runnable
{
    private static int static_i;//靜態變量

    public void run()
    {
        static_i = 4;
        System.out.println("[" + Thread.currentThread().getName()
                + "]獲取static_i 的值:" + static_i);
        static_i = 10;
        System.out.println("[" + Thread.currentThread().getName()
                + "]獲取static_i*2的值:" + static_i * 2);
    }

    public static void main(String[] args)
    {
        Test t = new Test();
        //啓動儘量多的線程才能很容易的模擬問題
        for (int i = 0; i < 3000; i++)
        {
            //t可以換成new Test(),保證每個線程都在不同的對象中執行，結果一樣
            new Thread(t, "線程" + i).start();
        }
    }
}

根據代碼註釋中模擬的情況，當線程1執行了static_i = 4;static_i = 10; 後，線程2獲得執行權，static_i = 4;然後當線程1獲得執行權執行static_i * 2; 必然輸出結果4*2=8，按照這個模擬，我們可能會在控制檯看到輸出爲8的結果。

寫道

[線程27]獲取static_i 的值:4
[線程22]獲取static_i*2的值:20
[線程28]獲取static_i 的值:4
[線程23]獲取static_i*2的值:8
[線程29]獲取static_i 的值:4
[線程30]獲取static_i 的值:4
[線程31]獲取static_i 的值:4
[線程24]獲取static_i*2的值:20

看紅色標註的部分，確實出現了我們的預想，同樣也證明了我們的結論。

實例成員變量 線程安全問題模擬：

----------------------------------------------------------------------------------

public class Test implements Runnable
{
    private int instance_i;//實例變量

    public void run()
    {
        instance_i = 4;
        System.out.println("[" + Thread.currentThread().getName()
                + "]獲取instance_i 的值:" + instance_i);
        instance_i = 10;
        System.out.println("[" + Thread.currentThread().getName()
                + "]獲取instance_i*2的值:" + instance_i * 2);
    }

    public static void main(String[] args)
    {
        Test t = new Test();
        //啓動儘量多的線程才能很容易的模擬問題
        for (int i = 0; i < 3000; i++)
        {
            //每個線程對在對象t中運行，模擬單例情況
            new Thread(t, "線程" + i).start();
        }
    }
}

按照本文開頭的分析，猶如靜態變量那樣，每個線程都在修改同一個對象的實例變量，肯定會出現線程安全問題。

寫道

[線程66]獲取instance_i 的值:10
[線程33]獲取instance_i*2的值:20
[線程67]獲取instance_i 的值:4
[線程34]獲取instance_i*2的值:8
[線程35]獲取instance_i*2的值:20
[線程68]獲取instance_i 的值:4

看紅色字體，可知單例情況下，實例變量線程非安全。

將new Thread(t, "線程" + i).start();改成new Thread(new Test(), "線程" + i).start();模擬非單例情況，會發現不存在線程安全問題。

局部變量線程安全問題模擬：

----------------------------------------------------------------------------------

public class Test implements Runnable
{
    public void run()
    {
        int local_i = 4;
        System.out.println("[" + Thread.currentThread().getName()
                + "]獲取local_i 的值:" + local_i);
        local_i = 10;
        System.out.println("[" + Thread.currentThread().getName()
                + "]獲取local_i*2的值:" + local_i * 2);
    }

    public static void main(String[] args)
    {
        Test t = new Test();
        //啓動儘量多的線程才能很容易的模擬問題
        for (int i = 0; i < 3000; i++)
        {
            //每個線程對在對象t中運行，模擬單例情況
            new Thread(t, "線程" + i).start();
        }
    }
}

控制檯沒有出現異常數據。

靜態方法 是否是線程安全的：

先看一個類

public class  Test{
public static  String hello(String str){
    String tmp="";
    tmp  =  tmp+str;
   return tmp;
}
}

hello方法會不會有多線程安全問題呢？不會！

靜態方法如果沒有使用靜態變量，則沒有線程安全問題。

爲什麼呢？因爲靜態方法內聲明的變量，每個線程調用時，都會新創建一份，而不會共用一個存儲單元。比如這裏的tmp，每個線程都會創建自己的一份，因此不會有線程安全問題。

注意，靜態成員變量，由於是在類加載時佔用一個存儲區，每個線程都是共用這個存儲區的，所以如果在靜態方法裏使用了靜態成員變量，這就會有線程安全問題。即只要方法內含有靜態成員變量，就是非線程安全的，（實際上歸根到底還是變量的線程安全問題~）。