java volatile關鍵字

時間 2019-11-11

原文原文鏈接

用在多線程，同步變量。線程爲了提升效率，將某成員變量(如A)拷貝了一份（如B），線程中對A的訪問其實訪問的是B。只在某些動做時才進行A和B的同步。所以存在A和B不一致的狀況。volatile就是用來避免這種狀況的。volatile告訴jvm，它所修飾的變量不保留拷貝，直接訪問主內存中的（也就是上面說的A)html

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

版權聲明：轉載時請以超連接形式標明文章原始出處和做者信息及本聲明
 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：

=========================分割線2=================================多線程

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

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消耗更多資源。jvm

=========================分割線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關鍵字不起做用，也就是說以下的表達式都不是原子操做：this

n = n + 1 ;
n ++ ;

若是要想使這種狀況變成原子操做，須要使用synchronized關鍵字，如上的代碼能夠改爲以下的形式：atom

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+一、n++ 等，volatile關鍵字將失效，只有當變量的值和自身上一個值無關時對該變量的操做纔是原子級別的，如n = m + 1，這個就是原級別的。因此在使用volatile關鍵時必定要謹慎，若是本身沒有把握，可使用synchronized來代替volatile。

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