volatile關鍵字相信瞭解Java多執行緒的讀者都很清楚它的作用。volatile關鍵字用於宣告簡單型別變數，如int、float、boolean等資料型別。如果這些簡單資料型別宣告為volatile，對它們的操作就會變成原子級別的。但這有一定的限制。例如，下面的例子中的n就不是原子級別的：

1. package mythread;  
2. publicclass JoinThread extends Thread  
3. {  
4. publicstaticvolatileint n = 0;  
5. publicvoid run()  
6.     {  
7. for (int i = 0; i < 10; i++)  
8. try
9.         {  
10.                 n = n + 1;  
11.                 sleep(3); // 為了使執行結果更隨機，延遲3毫秒 
12.             }  
13. catch (Exception e)  
14.             {  
15.             }  
16.     }  
17. publicstaticvoid main(String[] args) throws Exception  
18.     {  
19.         Thread threads[] = new Thread[100];  
20. for (int i = 0; i < threads.length; i++)  
21. // 建立100個執行緒 
22.             threads[i] = new JoinThread();  
23. for (int i = 0; i < threads.length; i++)  
24. // 執行剛才建立的100個執行緒 
25.             threads[i].start();  
26. for (int i = 0; i < threads.length; i++)  
27. // 100個執行緒都執行完後繼續 
28.             threads[i].join();  
29.         System.out.println("n=" + JoinThread.n);  
30.     }  
31. }  

如果對n的操作是原子級別的，最後輸出的結果應該為n=1000，而在執行上面積程式碼時，很多時侯輸出的n都小於1000，這說明n=n+1不是原子級別的操作。原因是宣告為volatile的簡單變數如果當前值由該變數以前的值相關，那麼volatile關鍵字不起作用，也就是說如下的表示式都不是原子操作：

n = n + 1;
n++;

如果要想使這種情況變成原子操作，需要使用synchronized關鍵字，如上的程式碼可以改成如下的形式：

1. package mythread;  
2. publicclass JoinThread extends Thread  
3. {  
4. publicstaticint n = 0;  
5. publicstaticsynchronizedvoid inc()  
6.     {  
7.         n++;  
8.     }  
9. publicvoid run()  
10.     {  
11. for (int i = 0; i < 10; i++)  
12. try
13.             {  
14.                 inc(); // n = n + 1 改成了 inc(); 
15.                 sleep(3); // 為了使執行結果更隨機，延遲3毫秒 
16.             }  
17. catch (Exception e)  
18.             {  
19.             }  
20.     }  
21. publicstaticvoid main(String[] args) throws Exception  
22.     {  
23.         Thread threads[] = new Thread[100];  
24. for (int i = 0; i < threads.length; i++)  
25. // 建立100個執行緒 
26.             threads[i] = new JoinThread();  
27. for (int i = 0; i < threads.length; i++)  
28. // 執行剛才建立的100個執行緒 
29.             threads[i].start();  
30. for (int i = 0; i < threads.length; i++)  
31. // 100個執行緒都執行完後繼續 
32.             threads[i].join();  
33.         System.out.println("n=" + JoinThread.n);  
34.     }  
35. }  

上面的程式碼將n=n+1改成了inc()，其中inc方法使用了synchronized關鍵字進行方法同步。因此，在使用volatile關鍵字時要慎重，並不是只要簡單型別變數使用volatile修飾，對這個變數的所有操作都是原來操作，當變數的值由自身的上一個決定時，如n=n+1、n++等，volatile關鍵字將失效，只有當變數的值和自身上一個值無關時對該變數的操作才是原子級別的，如n = m + 1，這個就是原級別的。所以在使用volatile關鍵時一定要謹慎，如果自己沒有把握，可以使用synchronized來代替volatile。