一、java記憶體模型與多執行緒程式設計中的三個感念

1、原子性

原子性是指一些操作或者全都執行，要麼或者全都不執行，整個操作作為一個整體是不可分割的，例如，一個銀行中有兩個賬戶A，B，現在要從A賬戶中轉賬500元到B賬戶，那麼一共可以分為兩個步驟：
1、從A賬戶取出500元：A = A - 500；
2、向B賬戶存入500元：B = B + 500；
這兩個步驟作為一個整體，要麼全部執行要麼全部都不執行，如果只執行步驟一，那麼A賬戶就會莫名其妙的丟失500元，B賬戶卻什麼都沒有收到。

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

例如：

i = 3;
i = i+3;
i++;
i = j;

這四條語句只有第一條語句是原子的，是基本的賦值操作。其他的三條語句，看似是賦值的原子操作，實際上卻是由多個步驟構成的。比如i++這條語句是由i，i+1,i=i+1這三條語句構成的，每一個語句都是原子的，但是合起來就不是原子的了。

2、可見性

可見性是指當多個執行緒訪問同一個變數時，一個執行緒修改了這個變數的值，其他執行緒能夠立即看得到修改的值。例如：

//執行緒1
i = 10;
i = i+3;


//執行緒2
j=i;

在java中每個執行緒都有自己的執行緒棧，當一個執行緒執行需要資料時，會到記憶體中將需要的資料複製到自己的執行緒棧中，然後對執行緒棧中的副本進行操作，再操作完成後再將資料寫回到記憶體中。

例如：執行緒1將i的值讀到自己的執行緒棧中，然後對i進行了加3操作，但是這一操作並沒有被及時的寫回到記憶體中，所以執行緒2在執行時看到的i的值仍然是3，這就是可見性的問題。

java提供的volitale關鍵字可以保證資料的可見性。

3、有序性

有序性：即程式執行的順序按照程式碼的先後順序執行。我們寫程式碼會有一個先後的順序，但是那僅僅是我們看到的順序，但是當編譯器編譯時會進行指令重排，於是程式碼的執行順序有可能和我們想的不一樣。例如：

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

flag = true;          //語句2

語句1和語句2的執行順序改變一下對程式的結果並沒有什麼影響，所以這時可能會改變這兩條指令的順序。那麼語句2會不會在語句3之前執行呢，答案是不會呢，因為語句2用到了語句3宣告的變數，這時編譯器會限制語句的執行順序來保證程式的正確性。

在單執行緒中，改變指令的順序可能不會產生不良後果，但是在多執行緒中就不一定了。例如：

//執行緒1:
context = loadContext();   //語句1
inited = true;             //語句2

//執行緒2:
while(!inited ){
  sleep()
}
doSomethingwithconfig(context);

由於語句1和語句2沒有資料依賴性，所以編譯器可能會將兩條指令重新排序，如果先執行語句2，這時執行緒1被阻塞，然後執行緒2的while迴圈條件不滿足，接著往下執行，但是由於context沒有賦值，於是會產生錯誤。

二、volitale關鍵字的作用

volitale關鍵字保證了可見性和一定程度上的有序性，但是不能保證原子性。

1、volitale關鍵字保證可見性

一旦一個共享變數（類的成員變數、類的靜態成員變數）被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的快取行無效；

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

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

　　那麼執行緒1讀取到的就是最新的正確的值。

2、volitale關鍵字不能保證原子性

從上面知道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也無法保證對變數的任何操作都是原子性的。

3、volitale關鍵字在一定程度上保證有序性

在前面提到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已經初始化完畢。