volitile關鍵字

weixin_34162629發表於2018-01-12

1.volatile關鍵字的兩層語義

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

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

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

先看一段程式碼，假如執行緒1先執行，執行緒2後執行：

//執行緒1
boolean stop = false;
while(!stop){
    doSomething();
}
 
//執行緒2
stop = 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。使用表格描述上述過程：

inc自增操作步驟	執行緒1	執行緒2
讀取inc	1	3
inc加1操作	2	4
inc寫入記憶體	6	5

按照1-6步驟執行的話，兩個執行緒對inc加1之後，inc的值還是1。

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

根源就在這裡，自增操作不是原子性操作，而且volatile也無法保證對變數的任何操作都是原子性的。但是，上面一個例子對stop變數的修改是原子性的。

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

採用synchronized (對inc++自增操作使用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包下提供了一些原子操作類，即對基本資料型別的自增（加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;        //語句1
y = 0;        //語句2
flag = true;  //語句3
x = 4;         //語句4
y = -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();   //語句1
inited = 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;
    }
}