java內存模型(JMM)和happens-before

文章目錄

我們知道java程序是運行在JVM中的，而JVM就是構建在內存上的虛擬機，那麼內存模型JMM是做什麼用的呢？

我們考慮一個簡單的賦值問題：

int a=100;

JMM考慮的就是什麼情況下讀取變量a的線程可以看到值爲100。看起來這是一個很簡單的問題，賦值之後不就可以讀到值了嗎？

但是上面的只是我們源碼的編寫順序，當把源碼編譯之後，在編譯器中生成的指令的順序跟源碼的順序並不是完全一致的。處理器可能採用亂序或者並行的方式來執行指令（在JVM中只要程序的最終執行結果和在嚴格串行環境中執行結果一致，這種重排序是允許的）。並且處理器還有本地緩存，當將結果存儲在本地緩存中，其他線程是無法看到結果的。除此之外緩存提交到主內存的順序也肯能會變化。

上面提到的種種可能都會導致在多線程環境中產生不同的結果。在多線程環境中，大部分時間多線程都是在執行各自的任務，只有在多個線程需要共享數據的時候，才需要協調線程之間的操作。

而JMM就是JVM中必須遵守的一組最小保證，它規定了對於變量的寫入操作在什麼時候對其他線程是可見的。

重排序

上面講了JVM中的重排序，這裏我們舉個例子，以便大家對重排序有一個更深入的理解：

@Slf4j
public class Reorder {

    int x=0, y=0;
    int a=0, b=0;

    private  void reorderMethod() throws InterruptedException {

        Thread one = new Thread(()->{
            a=1;
            x=b;
        });

        Thread two = new Thread(()->{
            b=1;
            y=a;
        });
        one.start();
        two.start();
        one.join();
        two.join();
        log.info("{},{}", x, y);
    }

    public static void main(String[] args) throws InterruptedException {

        for (int i=0; i< 100; i++){
            new Reorder().reorderMethod();
        }
    }
}

上面的例子是一個很簡單的併發程序。由於我們沒有使用同步限制，所以線程one和two的執行順序是不定的。有可能one在two之前執行，也有可能在two之後執行，也可能兩者同時執行。不同的執行順序可能會導致不同的輸出結果。

同時雖然我們在代碼中指定了先執行a=1, 再執行x=b，但是這兩條語句實際上是沒有關係的，在JVM中完全可能將兩條語句重排序成x=b在前，a=1在後，從而導致輸出更多意想不到的結果。

Happens-Before

爲了保證java內存模型中的操作順序，JMM爲程序中的所有操作定義了一個順序關係，這個順序叫做Happens-Before。要想保證操作B看到操作A的結果，不管A和B是在同一線程還是不同線程，那麼A和B必須滿足Happens-Before的關係。如果兩個操作不滿足happens-before的關係，那麼JVM可以對他們任意重排序。

我們看一下happens-before的規則：

程序順序規則：如果在程序中操作A在操作B之前，那麼在同一個線程中操作A將會在操作B之前執行。

注意，這裏的操作A在操作B之前執行是指在單線程環境中，雖然虛擬機會對相應的指令進行重排序，但是最終的執行結果跟按照代碼順序執行是一樣的。虛擬機只會對不存在依賴的代碼進行重排序。

監視器鎖規則：監視器上的解鎖操作必須在同一個監視器上面的加鎖操作之前執行。

鎖我們大家都很清楚了，這裏的順序必須指的是同一個鎖，如果是在不同的鎖上面，那麼其執行順序也不能得到保證。

volatile變量規則：對volatile變量的寫入操作必須在對該變量的讀操作之前執行。

原子變量和volatile變量在讀寫操作上面有着相同的語義。

線程啓動規則：線程上對Thread.start的操作必須要在該線程中執行任何操作之前執行。
線程結束規則：線程中的任何操作都必須在其他線程檢測到該線程結束之前執行。
中斷規則：當一個線程再另一個線程上調用interrupt時，必須在被中斷線程檢測到interrupt調用之前執行。
終結器規則：對象的構造函數必須在啓動該對象的終結器之前執行完畢。
傳遞性：如果操作A在操作B之前執行，並且操作B在操作C之前執行，那麼操作A必須在操作C之前執行。

上面的規則2很好理解，在加鎖的過程中，不允許其他的線程獲得該鎖，也意味着其他的線程必須等待鎖釋放之後才能加鎖和執行其業務邏輯。

4，5，6，7規則也很好理解，只有開始，才能結束。這符合我們對程序的一般認識。

8的傳遞性相信學過數學的人應該也不難理解。

接下來我們重點討論一下規則3和規則1的結合。討論之前我們再總結一下happens-before到底是做什麼的。

因爲JVM會對接收到的指令進行重排序，爲了保證指令的執行順序，我們纔有了happens-before規則。上面講到的2，3，4，5，6，7規則可以看做是重排序的節點，這些節點是不允許重排序的，只有在這些節點之間的指令才允許重排序。

結合規則1程序順序規則，我們得到其真正的含義：代碼中寫在重排序節點之前的指令，一定會在重排序節點執行之前執行。

重排序節點就是一個分界點，它的位置是不能夠移動的。看一下下面的直觀例子：

線程1中有兩個指令：set i=1, set volatile a=2。
線程2中也有兩個指令：get volatile a, get i。

按照上面的理論，set和get volatile是兩個重排序節點，set必須排在get之前。而依據規則1，代碼中set i=1 在set volatile a=2之前，因爲set volatile是重排序節點，所以需要遵守程序順序執行規則，從而set i=1要在set volatile a=2之前執行。同樣的道理get volatile a在get i之前執行。最後導致i=1在get i之前執行。

這個操作叫做藉助同步。

安全發佈

我們經常會用到單例模式來創建一個單的對象，我們看下下面的方法有什麼不妥：

public class Book {

    private static Book book;

    public static Book getBook(){
        if(book==null){
            book = new Book();
        }
        return book;
    }
}

上面的類中定義了一個getBook方法來返回一個新的book對象，返回對象之前，我們先判斷了book是否爲空，如果不爲空的話就new一個book對象。

初看起來，好像沒什麼問題，但是如果仔細考慮JMM的重排規則，就會發現問題所在。
book=new Book（）其實一個複雜的命令，並不是原子性操作。它大概可以分解爲1.分配內存，2.實例化對象，3.將對象和內存地址建立關聯。

其中2和3有可能會被重排序，然後就有可能出現book返回了，但是還沒有初始化完畢的情況。從而出現不可以預見的錯誤。

根據上面我們講到的happens-before規則，最簡單的辦法就是給方法前面加上synchronized關鍵字：

public class Book {

    private static Book book;

    public synchronized static Book getBook(){
        if(book==null){
            book = new Book();
        }
        return book;
    }
}

我們再看下面一種靜態域的實現：

public class BookStatic {
    private static BookStatic bookStatic= new BookStatic();

    public static BookStatic getBookStatic(){
        return bookStatic;
    }
}

JVM在類被加載之後和被線程使用之前，會進行靜態初始化，而在這個初始化階段將會獲得一個鎖，從而保證在靜態初始化階段內存寫入操作將對所有的線程可見。

上面的例子定義了static變量，在靜態初始化階段將會被實例化。這種方式叫做提前初始化。

下面我們再看一個延遲初始化佔位類的模式：


public class BookStaticLazy {

    private static class BookStaticHolder{
        private static BookStaticLazy bookStatic= new BookStaticLazy();
    }

    public static BookStaticLazy getBookStatic(){
        return BookStaticHolder.bookStatic;
    }
}

上面的類中，只有在調用getBookStatic方法的時候纔會去初始化類。

接下來我們再介紹一下雙重檢查加鎖。

public class BookDLC {
    private volatile static BookDLC bookDLC;

    public static BookDLC getBookDLC(){
        if(bookDLC == null ){
            synchronized (BookDLC.class){
                if(bookDLC ==null){
                    bookDLC=new BookDLC();
                }
            }
        }
        return bookDLC;
    }
}

上面的類中檢測了兩次bookDLC的值，只有bookDLC爲空的時候才進行加鎖操作。看起來一切都很完美，但是我們要注意一點，這裏bookDLC一定要是volatile。

因爲bookDLC的賦值操作和返回操作並沒有happens-before，所以可能會出現獲取到一個僅部分構造的實例。這也是爲什麼我們要加上volatile關鍵詞。

初始化安全性

本文的最後，我們將討論一下在構造函數中含有final域的對象初始化。

對於正確構造的對象，初始化對象保證了所有的線程都能夠正確的看到由構造函數爲對象給各個final域設置的正確值，包括final域可以到達的任何變量（比如final數組中的元素，final的hashMap等）。

public class FinalSafe {
    private final HashMap<String,String> hashMap;

    public FinalSafe(){
        hashMap= new HashMap<>();
        hashMap.put("key1","value1");
    }
}

上面的例子中，我們定義了一個final對象，並且在構造函數中初始化了這個對象。那麼這個final對象是將不會跟構造函數之後的其他操作重排序。

本文的例子可以參考https://github.com/ddean2009/learn-java-concurrency/tree/master/reorder

更多內容請訪問 flydean的博客

java內存模型(JMM)和happens-before

文章目錄

重排序

Happens-Before

安全發佈

初始化安全性

java程序員從小工到專家成神之路（2020版）

由於不當的執行順序導致的死鎖

一文讀懂密碼學中的證書

都2020年了,這5個java IDE神器你還不知道？

一篇文章讓你徹底弄懂SSL/TLS協議

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結