Java中JMM和volatile關鍵字如何使用

Java中JMM和volatile關鍵字如何使用，很多新手對此不是很清楚，為了幫助大家解決這個難題，下面小編將為大家詳細講解，有這方面需求的人可以來學習下，希望你能有所收獲。

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);

看完上述內容是否對您有幫助呢？如果還想對相關知識有進一步的了解或閱讀更多相關文章，請關注億速云行業資訊頻道，感謝您對億速云的支持。