java中volatile關鍵字

標籤：java   volatile   多線程   

java中volatile關鍵字

學習ImageLoader源碼時遇到遇到這麼一個關鍵字，以前沒遇到過，也不明白是何含義，網上找了部分資料，總結記錄一下。

在java線程並發處理中，有一個關鍵字volatile的使用目前存在很大的混淆，以為使用這個關鍵字，在進行多線程並發處理的時候就可以萬事大吉。Java語言是支援多線程的，為瞭解決線程並發的問題，在語言內部引入了 同步塊 和 volatile 關鍵字機制。

 

synchronized 

同步塊大家都比較熟悉，通過 synchronized 關鍵字來實現，所有加上synchronized 和 塊語句，在多線程訪問的時候，同一時刻只能有一個線程能夠用synchronized 修飾的方法 或者 代碼塊。

volatile

用volatile修飾的變數，線程在每次使用變數的時候，都會讀取變數修改後的最的值。volatile很容易被誤用，用來進行原子性操作。

剖析volatile關鍵字

1. volatile關鍵字的兩層語義

　　一旦一個共用變數（類的成員變數、類的靜態成員變數）被volatile修飾之後，那麼就具備了兩層語義：

　　1）保證了不同線程對這個變數進行操作時的可見度，即一個線程修改了某個變數的值，這新值對其他線程來說是立即可見的。

　　2）禁止進行指令重排序。

　　先看一段代碼，假如線程1先執行，線程2後執行：

//線程1boolean stop = false;while(!stop){    doSomething();}  //線程2stop = true;

 　　這段代碼是很典型的一段代碼，很多人在中斷線程時可能都會採用這種標記辦法。但是事實上，這段代碼會完全運行正確嗎？即一定會將線程中斷嗎？不一定，也許在大多數時候，這個代碼能夠把線程中斷，但是也有可能會導致無法中斷線程（雖然這個可能性很小，但是只要一旦發生這種情況就會造成死迴圈了）。

　　下面解釋一下這段代碼為何有可能導致無法中斷線程。在前面已經解釋過，每個線程在運行過程中都有自己的工作記憶體，那麼線程1在啟動並執行時候，會將stop變數的值拷貝一份放在自己的工作記憶體當中。

　　那麼當線程2更改了stop變數的值之後，但是還沒來得及寫入主存當中，線程2轉去做其他事情了，那麼線程1由於不知道線程2對stop變數的更改，因此還會一直迴圈下去。

　　但是用volatile修飾之後就變得不一樣了：

　　第一：使用volatile關鍵字會強制將修改的值立即寫入主存；

　　第二：使用volatile關鍵字的話，當線程2進行修改時，會導致線程1的工作記憶體中緩衝變數stop的緩衝行無效（反映到硬體層的話，就是CPU的L1或者L2緩衝中對應的緩衝行無效）；

　　第三：由於線程1的工作記憶體中緩衝變數stop的緩衝行無效，所以線程1再次讀取變數stop的值時會去主存讀取。

　　那麼線上程2修改stop值時（當然這裡包括2個操作，修改線程2工作記憶體中的值，然後將修改後的值寫入記憶體），會使得線程1的工作記憶體中緩衝變數stop的緩衝行無效，然後線程1讀取時，發現自己的緩衝行無效，它會等待緩衝行對應的主存地址被更新之後，然後去對應的主存讀取最新的值。

　　那麼線程1讀取到的就是最新的正確的值。

2. volatile保證原子性嗎？

　　從上面知道volatile關鍵字保證了操作的可見度，但是volatile能保證對變數的操作是原子性嗎？

　　下面看一個例子：

        

public class Test {    public volatile int inc = 0;          public void increase() {        inc++;    }          public static void main(String[] args) {        final Test test = new Test();        for(int i=0;i<10;i++){            new Thread(){                public void run() {                    for(int j=0;j<1000;j++)                        test.increase();                };            }.start();        }                  while(Thread.activeCount()>1)  //保證前面的線程都執行完            Thread.yield();        System.out.println(test.inc);    }}

 　　大家想一下這段程式的輸出結果是多少？也許有些朋友認為是10000。但是事實上運行它會發現每次運行結果都不一致，都是一個小於10000的數字。

　　可能有的朋友就會有疑問，不對啊，上面是對變數inc進行自增操作，由於volatile保證了可見度，那麼在每個線程中對inc自增完之後，在其他線程中都能看到修改後的值啊，所以有10個線程分別進行了1000次操作，那麼最終inc的值應該是1000*10=10000。

　　這裡面就有一個誤區了，volatile關鍵字能保證可見度沒有錯，但是上面的程式錯在沒能保證原子性。可見度只能保證每次讀取的是最新的值，但是volatile沒辦法保證對變數的操作的原子性。

　　在前面已經提到過，自增操作是不具備原子性的，它包括讀取變數的原始值、進行加1操作、寫入工作記憶體。那麼就是說自增操作的三個子操作可能會分割開執行，就有可能導致下面這種情況出現：

　　假如某個時刻變數inc的值為10，

　　線程1對變數進行自增操作，線程1先讀取了變數inc的原始值，然後線程1被阻塞了；

　　然後線程2對變數進行自增操作，線程2也去讀取變數inc的原始值，由於線程1隻是對變數inc進行讀取操作，而沒有對變數進行修改操作，所以不會導致線程2的工作記憶體中緩衝變數inc的緩衝行無效，所以線程2會直接去主存讀取inc的值，發現inc的值時10，然後進行加1操作，並把11寫入工作記憶體，最後寫入主存。

　　然後線程1接著進行加1操作，由於已經讀取了inc的值，注意此時線上程1的工作記憶體中inc的值仍然為10，所以線程1對inc進行加1操作後inc的值為11，然後將11寫入工作記憶體，最後寫入主存。

　　那麼兩個線程分別進行了一次自增操作後，inc只增加了1。

　　解釋到這裡，可能有朋友會有疑問，不對啊，前面不是保證一個變數在修改volatile變數時，會讓緩衝行無效嗎？然後其他線程去讀就會讀到新的值，對，這個沒錯。這個就是上面的happens-before規則中的volatile變數規則，但是要注意，線程1對變數進行讀取操作之後，被阻塞了的話，並沒有對inc值進行修改。然後雖然volatile能保證線程2對變數inc的值讀取是從記憶體中讀取的，但是線程1沒有進行修改，所以線程2根本就不會看到修改的值。

　　根源就在這裡，自增操作不是原子性操作，而且volatile也無法保證對變數的任何操作都是原子性的。

把上面的代碼改成以下任何一種都可以達到效果：

採用synchronized：

public class Test {    public  int inc = 0;        public synchronized void increase() {        inc++;    }        public static void main(String[] args) {        final Test test = new Test();        for(int i=0;i<10;i++){            new Thread(){                public void run() {                    for(int j=0;j<1000;j++)                        test.increase();                };            }.start();        }                while(Thread.activeCount()>1)  //保證前面的線程都執行完            Thread.yield();        System.out.println(test.inc);    }}

採用Lock：

public class Test {    public  int inc = 0;    Lock lock = new ReentrantLock();        public  void increase() {        lock.lock();        try {            inc++;        } finally{            lock.unlock();        }    }        public static void main(String[] args) {        final Test test = new Test();        for(int i=0;i<10;i++){            new Thread(){                public void run() {                    for(int j=0;j<1000;j++)                        test.increase();                };            }.start();        }                while(Thread.activeCount()>1)  //保證前面的線程都執行完            Thread.yield();        System.out.println(test.inc);    }}

採用AtomicInteger：

public class Test {    public  AtomicInteger inc = new AtomicInteger();         public  void increase() {        inc.getAndIncrement();    }        public static void main(String[] args) {        final Test test = new Test();        for(int i=0;i<10;i++){            new Thread(){                public void run() {                    for(int j=0;j<1000;j++)                        test.increase();                };            }.start();        }                while(Thread.activeCount()>1)  //保證前面的線程都執行完            Thread.yield();        System.out.println(test.inc);    }}

　　在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作類，即對基礎資料型別 (Elementary Data Type)的 自增（加1操作），自減（減1操作）、以及加法操作（加一個數），減法操作（減一個數）進行了封裝，保證這些操作是原子性操作。atomic是利用CAS來實現原子性操作的（Compare And Swap），CAS實際上是利用處理器提供的CMPXCHG指令實現的，而處理器執行CMPXCHG指令是一個原子性操作。

3.volatile能保證有序性嗎？

　　在前面提到volatile關鍵字能禁止指令重排序，所以volatile能在一定程度上保證有序性。

　　volatile關鍵字禁止指令重排序有兩層意思：

　　1）當程式執行到volatile變數的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行，且結果已經對後面的操作可見；在其後面的操作肯定還沒有進行；

　　2）在進行指令最佳化時，不能將在對volatile變數訪問的語句放在其後面執行，也不能把volatile變數後面的語句放到其前面執行。

　　可能上面說的比較繞，舉個簡單的例子：

       

//x、y為非volatile變數//flag為volatile變數  x = 2;        //語句1y = 0;        //語句2flag = true;  //語句3x = 4;         //語句4y = -1;       //語句5

 　　由於flag變數為volatile變數，那麼在進行指令重排序的過程的時候，不會將語句3放到語句1、語句2前面，也不會講語句3放到語句4、語句5後面。但是要注意語句1和語句2的順序、語句4和語句5的順序是不作任何保證的。

　　並且volatile關鍵字能保證，執行到語句3時，語句1和語句2必定是執行完畢了的，且語句1和語句2的執行結果對語句3、語句4、語句5是可見的。

　　那麼我們回到前面舉的一個例子：

//線程1:context = loadContext();   //語句1inited = true;             //語句2  //線程2:while(!inited ){  sleep() }doSomethingwithconfig(context);

 　　前面舉這個例子的時候，提到有可能語句2會在語句1之前執行，那麼久可能導致context還沒被初始化，而線程2中就使用未初始化的context去進行操作，導致程式出錯。

　　這裡如果用volatile關鍵字對inited變數進行修飾，就不會出現這種問題了，因為當執行到語句2時，必定能保證context已經初始化完畢。

4.volatile的原理和實現機制

　　前面講述了源於volatile關鍵字的一些使用，下面我們來探討一下volatile到底如何保證可見度和禁止指令重排序的。

　　下面這段話摘自《深入理解Java虛擬機器》：

　　“觀察加入volatile關鍵字和沒有加入volatile關鍵字時所產生的彙編代碼發現，加入volatile關鍵字時，會多出一個lock首碼指令”

　　lock首碼指令實際上相當於一個記憶體屏障（也成記憶體柵欄），記憶體屏障會提供3個功能：

　　1）它確保指令重排序時不會把其後面的指令排到記憶體屏障之前的位置，也不會把前面的指令排到記憶體屏障的後面；即在執行到記憶體屏障這句指令時，在它前面的操作已經全部完成；

　　2）它會強制將對緩衝的修改操作立即寫入主存；

　　3）如果是寫操作，它會導致其他CPU中對應的緩衝行無效。

使用volatile關鍵字的情境

synchronized關鍵字是防止多個線程同時執行一段代碼，那麼就會很影響程式執行效率，而volatile關鍵字在某些情況下效能要優於synchronized，但是要注意volatile關鍵字是無法替代synchronized關鍵字的，因為volatile關鍵字無法保證操作的原子性。通常來說，使用volatile必須具備以下2個條件：

　　1）對變數的寫操作不依賴於當前值

　　2）該變數沒有包含在具有其他變數的不變式中

　　實際上，這些條件表明，可以被寫入 volatile 變數的這些有效值獨立於任何程式的狀態，包括變數的目前狀態。

　　事實上，我的理解就是上面的2個條件需要保證操作是原子性操作，才能保證使用volatile關鍵字的程式在並發時能夠正確執行。

　　下面列舉幾個Java中使用volatile的幾個情境。

1.狀態標記量

volatile boolean flag = false;  while(!flag){    doSomething();}  public void setFlag() {    flag = true;}

volatile boolean inited = false;//線程1:context = loadContext();   inited = true;               //線程2:while(!inited ){sleep() }doSomethingwithconfig(context);

 

2.double check

class Singleton{    private volatile static Singleton instance = null;          private Singleton() {              }          public static Singleton getInstance() {        if(instance==null) {            synchronized (Singleton.class) {                if(instance==null)                    instance = new Singleton();            }        }        return instance;    }}

參考連結：

http://sakyone.iteye.com/blog/668091

http://www.cnblogs.com/dolphin0520/p/3920373.html

java中volatile關鍵字