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

 此處不贅述了，首先給出靜態變數、例項變數、區域性變數在多執行緒環境下的執行緒安全問題結論，然後用示例驗證，請大家擦亮眼睛，有錯必究，否則誤人子弟！

靜態變數：執行緒非安全。

靜態變數即類變數，位於方法區，為所有物件共享，共享一份記憶體，一旦靜態變數被修改，其他物件均對修改可見，故執行緒非安全。

例項變數：單例模式（只有一個物件例項存在）執行緒非安全，非單例執行緒安全。

例項變數為物件例項私有，在虛擬機器的堆中分配，若在系統中只存在一個此物件的例項，在多執行緒環境下，“猶如”靜態變數那樣，被某個執行緒修改後，其他執行緒對修改均可見，故執行緒非安全；如果每個執行緒執行都是在不同的物件中，那物件與物件之間的例項變數的修改將互不影響，故執行緒安全。

區域性變數：執行緒安全。

每個執行緒執行時將會把區域性變數放在各自棧幀的工作記憶體中，執行緒間不共享，故不存線上程安全問題。

靜態變數執行緒安全問題模擬：

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

1. /**  
2.   * 執行緒安全問題模擬執行  
3.   *  ------------------------------  
4.   *       執行緒1      |    執行緒2  
5.   *  ------------------------------  
6.   *   static_i = 4;  | 等待  
7.   *   static_i = 10; | 等待  
8.   *    等待          | static_i = 4;  
9.   *   static_i * 2;  | 等待  
10.   *  -----------------------------
     
11.  * */  
12. public class Test implements Runnable  
13. {  
14.     private static int static_i;//靜態變數   
15.     public void run()  
16.     {  
17.         static_i = 4;  
18.         System.out.println("[" + Thread.currentThread().getName()  
19.                 + "]獲取static_i 的值:" + static_i);  
20.         static_i = 10;  
21.         System.out.println("[" + Thread.currentThread().getName()  
22.                 + "]獲取static_i*3的值:" + static_i * 2);  
23.     }  
24.     public static void main(String[] args)  
25.     {  
26.         Test t = new Test();  
27.         //啟動儘量多的執行緒才能很容易的模擬問題   
28.         for (int i = 0; i < 3000; i++)  
29.         {  
30.             //t可以換成new Test(),保證每個執行緒都在不同的物件中執行，結果一樣   
31.             new Thread(t, "執行緒" + i).start();  
32.         }  
33.     }  
34. }  

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

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

例項變數執行緒安全問題模擬：

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

1. public class Test implements Runnable  
2. {  
3.     private int instance_i;//例項變數  
4.     public void run()  
5.     {  
6.         instance_i = 4;  
7.         System.out.println("[" + Thread.currentThread().getName()  
8.                 + "]獲取instance_i 的值:" + instance_i);  
9.         instance_i = 10;  
10.         System.out.println("[" + Thread.currentThread().getName()  
11.                 + "]獲取instance_i*3的值:" + instance_i * 2);  
12.     }  
13.     public static void main(String[] args)  
14.     {  
15.         Test t = new Test();  
16.         //啟動儘量多的執行緒才能很容易的模擬問題   
17.         for (int i = 0; i < 3000; i++)  
18.         {  
19.             //每個執行緒對在物件t中執行，模擬單例情況  
20.             new Thread(t, "執行緒" + i).start();  
21.         }  
22.     }  
23. }  

按照本文開頭的分析，猶如靜態變數那樣，每個執行緒都在修改同一個物件的例項變數，肯定會出現執行緒安全問題。

寫道

[執行緒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();模擬非單例情況，會發現不存線上程安全問題。

區域性變數執行緒安全問題模擬：

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

1. public class Test implements Runnable  
2. {  
3.     public void run()  
4.     {  
5.         int local_i = 4;  
6.         System.out.println("[" + Thread.currentThread().getName()  
7.                 + "]獲取local_i 的值:" + local_i);  
8.         local_i = 10;  
9.         System.out.println("[" + Thread.currentThread().getName()  
10.                 + "]獲取local_i*2的值:" + local_i * 2);  
11.     }  
12.     public static void main(String[] args)  
13.     {  
14.         Test t = new Test();  
15.         //啟動儘量多的執行緒才能很容易的模擬問題  
16.         for (int i = 0; i < 3000; i++)  
17.         {  
18.             //每個執行緒對在物件t中執行，模擬單例情況   
19.             new Thread(t, "執行緒" + i).start();  
20.         }  
21.     }  
22. }  

控制檯沒有出現異常資料。

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

以上只是通過簡單的例項來展示靜態變數、例項變數、區域性變數等的執行緒安全問題，

並未進行底層的分析，下一篇將對執行緒問題的底層進行剖析。

靜態方法是執行緒安全的

先看一個類

public class  Test{

public static  String hello(String str){

    String tmp="";

    tmp  =  tmp+str;

   return tmp;

}

}

hello方法會不會有多執行緒安全問題呢？沒有！！

靜態方法如果沒有使用靜態變數，則沒有執行緒安全問題。

為什麼呢？因為靜態方法內宣告的變數，每個執行緒呼叫時，都會新建立一份，而不會共用一個儲存單元。比如這裡的tmp,每個執行緒都會建立自己的一份，因此不會有執行緒安全問題

注意，靜態變數，由於是在類載入時佔用一個儲存區，每個執行緒都是共用這個儲存區的，所以如果在靜態方法裡使用了靜態變數，這就會有執行緒安全問題！