java volatile關鍵字

標籤：

  用在多線程，同步變數。 線程為了提高效率，將某成員變數(如A)拷貝了一份（如B），線程中對A的訪問其實訪問的是B。只在某些動作時才進行A和B的同步。因此存在A和B不一致的情況。volatile就是用來避免這種情況的。volatile告訴jvm， 它所修飾的變數不保留拷貝，直接存取主記憶體中的（也就是上面說的A)

 

=========================分割線1=================================

 

 

著作權聲明 ：轉載時請以超連結形式標明文章原始出處和作者資訊及本聲明 
http://aleung.blogbus.com/logs/32090434.html

在Java記憶體模型中，有main memory，每個線程也有自己的memory (例如寄存器)。為了效能，一個線程會在自己的memory中保持要訪問的變數的副本。這樣就會出現同一個變數在某個瞬間，在一個線程的memory中的值可能與另外一個線程memory中的值，或者main memory中的值不一致的情況。 一個變數聲明為volatile，就意味著這個變數是隨時會被其他線程修改的，因此不能將它cache線上程memory中。以下例子展現了volatile的作用：

public class StoppableTask extends Thread {
  private volatile boolean pleaseStop;
  public void run() {
    while (!pleaseStop) {
     // do some stuff...
    }
 }
  public void tellMeToStop() {
   pleaseStop = true;
  }
}

假如pleaseStop沒有被聲明為volatile，線程執行run的時候檢查的是自己的副本，就不能及時得知其他線程已經調用tellMeToStop()修改了pleaseStop的值。 Volatile一般情況下不能代替sychronized，因為volatile不能保證操作的原子性，即使只是i++，實際上也是由多個原子操作組成：read i; inc; write i，假如多個線程同時執行i++，volatile只能保證他們操作的i是同一塊記憶體，但依然可能出現寫入髒資料的情況。如果配合Java 5增加的atomic wrapper classes，對它們的increase之類的操作就不需要sychronized。 Reference：

• http://www.javamex.com/tutorials/synchronization_volatile.shtml
• http://www.javamex.com/tutorials/synchronization_volatile_java_5.shtml
• http://www.ibm.com/developerworks/cn/java/j-jtp06197.html

=========================分割線2=================================

 

  恐怕比較一下volatile和synchronized的不同是最容易解釋清楚的。volatile是變數修飾符，而synchronized則作用於一段代碼或方法；看如下三句get代碼：

int i1;             
int geti1() {return i1;} 
volatile int i2; 
int geti2()
{return i2;} 
int i3;              
synchronized int geti3() {return i3;}

　 　geti1()得到儲存在當前線程中i1的數值。多個線程有多個i1變數拷貝，而且這些i1之間可以互不相同。換句話說，另一個線程可能已經改變了它線 程內的i1值，而這個值可以和當前線程中的i1值不相同。事實上，Java有個思想叫“主”記憶體地區，這裡存放了變數目前的“準確值”。每個線程可以有它 自己的變數拷貝，而這個變數拷貝值可以和“主”記憶體地區裡存放的不同。因此實際上存在一種可能：“主”記憶體地區裡的i1值是1，線程1裡的i1值是2，線 程2裡的i1值是3——這線上程1和線程2都改變了它們各自的i1值，而且這個改變還沒來得及傳遞給“主”記憶體地區或其他線程時就會發生。
　　而 geti2()得到的是“主”記憶體地區的i2數值。用volatile修飾後的變數不允許有不同於“主”記憶體地區的變數拷貝。換句話說，一個變數經 volatile修飾後在所有線程中必須是同步的；任何線程中改變了它的值，所有其他線程立即擷取到了相同的值。理所當然的，volatile修飾的變數 存取時比一般變數消耗的資源要多一點，因為線程有它自己的變數拷貝更為高效。
　　既然volatile關鍵字已經實現了線程間資料同步，又要 synchronized幹什麼呢？呵呵，它們之間有兩點不同。首先，synchronized獲得並釋放監視器——如果兩個線程使用了同一個對象鎖，監 視器能強制保證代碼塊同時只被一個線程所執行——這是眾所周知的事實。但是，synchronized也同步記憶體：事實上，synchronized在“ 主”記憶體地區同步整個線程的記憶體。因此，執行geti3()方法做了如下幾步：
1. 線程請求獲得監視this對象的對象鎖（假設未被鎖，否則線程等待直到鎖釋放）
2. 線程記憶體的資料被消除，從“主”記憶體地區中讀入（Java虛擬機器能最佳化此步。。。[後面的不知道怎麼表達,汗]）
3. 代碼塊被執行
4. 對於變數的任何改變現在可以安全地寫到“主”記憶體地區中（不過geti3()方法不會改變變數值）
5. 線程釋放監視this對象的對象鎖
　　因此volatile只是線上程記憶體和“主”記憶體間同步某個變數的值，而synchronized通過鎖定和解鎖某個監視器同步所有變數的值。顯然synchronized要比volatile消耗更多資源。

 

=========================分割線3=================================

 

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

package  mythread;

public   class  JoinThread  extends  Thread
{
     public   static volatile int  n  =   0 ;
    public   void  run()
    {
         for  ( int  i  =   0 ; i  <   10 ; i ++ )
             try 
        {
                n  =  n  +   1 ;
                sleep( 3 );  //  為了使運行結果更隨機，延遲3毫秒 

            }
             catch  (Exception e)
            {
            }
    }

     public   static   void  main(String[] args)  throws  Exception
    {

        Thread threads[]  =   new  Thread[ 100 ];
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  建立100個線程 
            threads[i]  =   new  JoinThread();
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  運行剛才建立的100個線程 
            threads[i].start();
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  100個線程都執行完後繼續 
            threads[i].join();
        System.out.println( " n= "   +  JoinThread.n);
    }
}

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

n  =  n  +   1 ;
n ++ ;

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

package  mythread;

public   class  JoinThread  extends  Thread
{
     public   static int  n  =   0 ;

     public static   synchronized   void  inc()
    {
        n ++ ;
    }
     public   void  run()
    {
         for  ( int  i  =   0 ; i  <   10 ; i ++ )
             try 
            {
                inc();  //  n = n + 1 改成了 inc(); 
                sleep( 3 );  //  為了使運行結果更隨機，延遲3毫秒 

            }
             catch  (Exception e)
            {
            }
    }

     public   static   void  main(String[] args)  throws  Exception
    {

        Thread threads[]  =   new  Thread[ 100 ];
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  建立100個線程 
            threads[i]  =   new  JoinThread();
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  運行剛才建立的100個線程 
            threads[i].start();
         for  ( int  i  =   0 ; i  <  threads.length; i ++ )
             //  100個線程都執行完後繼續 
            threads[i].join();
        System.out.println( " n= "   +  JoinThread.n);
    }
}

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

 

轉自http://blog.csdn.net/orzorz/article/details/4319055

java volatile關鍵字