volatile(一)

在併發編程中，咱們一般會遇到如下三個問題：原子性問題，可見性問題，有序性問題。咱們先看具體看一下這三個概念：

1.原子性

 原子性：即一個操做或者多個操做 要麼所有執行而且執行的過程不會被任何因素打斷，要麼就都不執行。舉個例子，

i = 9;

 

倘若一個線程執行到這個語句時，我暫且假設爲一個32位的變量賦值包括兩個過程：爲低16位賦值，爲高16位賦值。

那麼就可能發生一種狀況：當將低16位數值寫入以後，忽然被中斷，而此時又有一個線程去讀取i的值，那麼讀取到的就是錯誤的數據。

在Java中，對基本數據類型的變量的讀取和賦值操做是原子性操做，即這些操做是不可被中斷的，要麼執行，要麼不執行。

上面一句話雖然看起來簡單，可是理解起來並非那麼容易。看下面一個例子i：

請分析如下哪些操做是原子性操做：

x = 10;         //語句1
y = x;         //語句2
x++;           //語句3
x = x + 1;     //語句4

咋一看，有些朋友可能會說上面的4個語句中的操做都是原子性操做。其實只有語句1是原子性操做，其餘三個語句都不是原子性操做。

語句1是直接將數值10賦值給x，也就是說線程執行這個語句的會直接將數值10寫入到工做內存中。

語句2實際上包含2個操做，它先要去讀取x的值，再將x的值寫入工做內存，雖然讀取x的值以及 將x的值寫入工做內存 這2個操做都是原子性操做，可是合起來就不是原子性操做了。

一樣的，x++和 x = x+1包括3個操做：讀取x的值，進行加1操做，寫入新的值。

因此上面4個語句只有語句1的操做具有原子性。

也就是說，只有簡單的讀取、賦值（並且必須是將數字賦值給某個變量，變量之間的相互賦值不是原子操做）纔是原子操做。

2.可見性

可見性是指當多個線程訪問同一個變量時，一個線程修改了這個變量的值，其餘線程可以當即看獲得修改的值。

3.有序性

有序性：即程序執行的順序按照代碼的前後順序執行。舉個簡單的例子，看下面這段代碼：

int i = 0;              
boolean flag = false;
i = 1;                //語句1  
flag = true;          //語句2

 

上面代碼定義了一個int型變量，定義了一個boolean類型變量，而後分別對兩個變量進行賦值操做。從代碼順序上看，語句1是在語句2前面的，那麼JVM在真正執行這段代碼的時候會保證語句1必定會在語句2前面執行嗎？不必定，爲何呢？這裏可能會發生指令重排序（Instruction Reorder）。

下面解釋一下什麼是指令重排序，通常來講，處理器爲了提升程序運行效率，可能會對輸入代碼進行優化，它不保證程序中各個語句的執行前後順序同代碼中的順序一致，可是它會保證程序最終執行結果和代碼順序執行的結果是一致的。

好比上面的代碼中，語句1和語句2誰先執行對最終的程序結果並無影響，那麼就有可能在執行過程當中，語句2先執行而語句1後執行。

好了，鋪墊完了，進入正題：

1.volatile關鍵字的兩層語義

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

1）保證了不一樣線程對這個變量進行操做時的可見性，即一個線程修改了某個變量的值，這新值對其餘線程來講是當即可見的。

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

2.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也沒法保證對變量的任何操做都是原子性的。

 

在前面提到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放到語句一、語句2前面，也不會講語句3放到語句四、語句5後面。可是要注意語句1和語句2的順序、語句4和語句5的順序是不做任何保證的。

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

 

 

 

 

jgolebiowski/graphAttack