Java併發編程：JMM和volatile關鍵字

轉載請標明出處：
http://blog.csdn.net/forezp/article/details/77580491
本文出自方誌朋的博客

Java內存模型

隨着計算機的CPU的飛速發展，CPU的運算能力已經遠遠超出了從主內存（運行內存）中讀取的數據的能力，爲了解決這個問題，CPU廠商設計出了CPU內置高速緩存區。高速緩存區的加入使得CPU在運算的過程當中直接從高速緩存區讀取數據，在必定程度上解決了性能的問題。但也引發了另一個問題，在CPU多核的狀況下，每一個處理器都有本身的緩存區，數據如何保持一致性。爲了保證多核處理器的數據一致性，引入多處理器的數據一致性的協議，這些協議包括MOSI、Synapse、Firely、DragonProtocol等。

JVM在執行多線程任務時，共享數據保存在主內存中，每個線程（執行再不一樣的處理器）有本身的高速緩存，線程對共享數據進行修改的時候，首先是從主內存拷貝到線程的高速緩存，修改以後，而後從高速緩存再拷貝到主內存。當有多個線程執行這樣的操做的時候，會致使共享數據出現不可預期的錯誤。

舉個例子：

i++;//操做

這個i++操做，線程首先從主內存讀取i的值，好比i=0，而後複製到本身的高速緩存區，進行i++操做，最後將操做後的結果從高速緩存區複製到主內存中。若是是兩個線程經過操做i++,預期的結果是2。這時結果然的爲2嗎？答案是否認的。線程1讀取主內存的i=0,複製到本身的高速緩存區，這時線程2也讀取i=0,複製到本身的高速緩存區，進行i++操做，怎麼最終獲得的結構爲1，而不是2。

爲了解決緩存不一致的問題，有兩種解決方案：

• 在總線加鎖，即同時只有一個線程能執行i++操做（包括讀取、修改等）。
• 經過緩存一致性協議

第一種方式就沒什麼好說的，就是同步代碼塊或者同步方法。也就只能一個線程能進行對共享數據的讀取和修改，其餘線程處於線程阻塞狀態。
第二種方式就是緩存一致性協議，好比Intel 的MESI協議，它的核心思想就是當某個處理器寫變量的數據，若是其餘處理器也存在這個變量，會發出信號量通知該處理器高速緩存的數據設置爲無效狀態。當其餘處理須要讀取該變量的時候，會讓其從新從主內存中讀，而後再複製到高速緩存區。

編髮編程的概念

併發編程的有三個概念，包括原子性、可見性、有序性。

原子性

原子性是指，操做爲原子性的，要麼成功，要麼失敗，不存在第三種狀況。好比：

String s="abc";

這個複雜操做是原子性的。再好比：

int i=0;
i++;

i=0這是一個賦值操做，這一步是原子性操做；那麼i++是原子性操做嗎？固然不是，首先它須要讀取i=0，而後須要執行運算，寫入i的新值1，它包含了讀取和寫入兩個步驟，因此不是原子性操做。

可見性

可見性是指共享數據的時候，一個線程修改了數據，其餘線程知道數據被修改，會從新讀取最新的主存的數據。
舉個例子：

i=0;//主內存

i++;//線程1

j=i;//線程2

線程1修改了i值，可是沒有將i值複製到主內存中，線程2讀取i的值，並將i的值賦值給j,咱們指望j=1,可是因爲線程1修改了，沒有來得及複製到主內存中，線程2讀取了i,並賦值給j，這時j的值爲0。
也就是線程i值被修改，其餘線程並不知道。

有序性

是指代碼執行的有序性，由於代碼有可能發生指令重排序（Instruction Reorder）。

Java 語言提供了 volatile 和 synchronized 兩個關鍵字來線程代碼操做的有序性，volatile 是由於其自己包含「禁止指令重排序」的語義，synchronized 在單線程中執行代碼，不管指令是否重排，最終的執行結果是一致的。

volatile詳解

volatile關鍵字做用

被volatile關鍵字修飾變量，起到了2個做用：

1.某個線程修改了被volatile關鍵字修飾變量是，根據數據一致性的協議，經過信號量，更改其餘線程的高速緩存中volatile關鍵字修飾變量狀態爲無效狀態，其餘線程若是須要重寫讀取該變量會再次從主內存中讀取，而不是讀取本身的高速緩存中的。

2.被volatile關鍵字修飾變量不會指令重排序。

volatile可以保證可見性和防止指令重排

在Java併發編程實戰一書中有這樣

public class NoVisibility {
    private static boolean ready;
    private static int a;

    public static void main(String[] args) throws InterruptedException {
        new ReadThread().start();
        Thread.sleep(100);
        a = 32;
        ready = true;
      

    }

    private static class ReadThread extends Thread {
        @Override
        public void run() {
            while (!ready) {
                Thread.yield();
            }
            System.out.println(a);
        }
    }
}

在上述代碼中，有可能（機率很是小，可是有這種可能性）永遠不會打印a的值，由於線程ReadThread讀取了主內存的ready爲false,主線程雖然更新了ready，可是ReadThread的高速緩存中並無更新。
另外：

a = 32;

ready = true;

這兩行代碼有可能發生指令重排。也就是能夠打印出a的值爲0。

若是在變量加上volatile關鍵字，能夠防止上述兩種不正常的狀況的發生。

volatile不能保證原子性

首先用一段代碼測試下，開起了10個線程，這10個線程共享一個變量inc（被volatile修飾），並在每一個線程循環1000次對inc進行inc++操做。咱們預期的結果是10000.

public class VolatileTest {


    public volatile int inc = 0;

    public void increase() {
        inc++;
    }

    public static void main(String[] args) throws InterruptedException {
        final VolatileTest test = new VolatileTest();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++)
                    test.increase();
            }).start();
        }
        //保證前面的線程都執行完
        Thread.sleep(3000);
        System.out.println(test.inc);
    }

}

屢次運行main函數，你會發現結果永遠都不會爲10000，都是小於10000。可能有這樣的疑問，volatile保證了共享數據的可見性，線程1修改了inc變量線程2會從新從主內存中從新讀，這樣就能保證inc++的正確性了啊，可爲何沒有獲得咱們預期的結果呢？

在以前已經講述過inc++這樣的操做不是一個原子性操做，它分爲讀、加加、寫。一種狀況，當線程1讀取了inc的值，尚未修改，線程2也讀取了，線程1修改完了，通知線程2將線程的緩存的 inc的值無效須要重讀，可這時它不須要讀取inc ，它仍執行寫操做，而後賦值給主線程，這時數據就會出現問題。

因此volatile不能保證原子性 。這時須要用鎖來保證,在increase方法加上synchronized，從新運行打印的結果爲10000 。

public synchronized void increase() {
        inc++;
}

volatile的使用場景

狀態標記

volatile最多見的使用場景是狀態標記，以下：

private volatile boolean asheep ;

//線程1
 
while(!asleep){
    countSheep();
}

//線程2
asheep=true;

防止指令重排

volatile boolean inited = false;
//線程1:
context = loadContext();  
inited = true;  
//上面兩行代碼若是不用volatile修飾，可能會發生指令重排，致使報錯
 
//線程2:
while(!inited ){
sleep()
}
doSomethingwithconfig(context);

參考資料

《Java 併發編程實戰》

《深刻理解JVM》

海子的博客：http://www.cnblogs.com/dolphin0520/p/3920373.html

掃碼關注公衆號有驚喜

（轉載本站文章請註明做者和出處 方誌朋的博客）