最近看到一篇比較好的介紹java內存模型的文章，特記錄下來

原文參考：https://juejin.im/post/5bf2977751882505d840321d

下文據原作者是看了《深入學習java虛擬機》總結出來的，博主也得找個時間去看看這本優秀的書才行了

一，內存模型產生背景

在介紹Java內存模型之前，我們先了解一下物理計算機中的併發問題，理解這些問題可以搞清楚內存模型產生的背景。物理機遇到的併發問題與虛擬機中的情況有不少相似之處，物理機的解決方案對虛擬機的實現有相當的參考意義。

物理機的併發問題

硬件的效率問題

計算機處理器處理絕大多數運行任務都不可能只靠處理器“計算”就能完成，處理器至少需要與內存交互，如讀取運算數據、存儲運算結果，這個I/O操作很難消除(無法僅靠寄存器完成所有運算任務)。

由於計算機的存儲設備與處理器的運算速度有幾個數量級的差距，爲了避免處理器等待緩慢的內存讀寫操作完成，現代計算機系統通過加入一層讀寫速度儘可能接近處理器運算速度的高速緩存。緩存作爲內存和處理器之間的緩衝：將運算需要使用到的數據複製到緩存中，讓運算能快速運行，當運算結束後再從緩存同步回內存之中。

緩存一致性問題

基於高速緩存的存儲系統交互很好地解決了處理器與內存速度的矛盾，但是也爲計算機系統帶來更高的複雜度，因爲引入了一個新問題：緩存一致性。

在多處理器的系統中(或者單處理器多核的系統)，每個處理器(每個核)都有自己的高速緩存，而它們有共享同一主內存(Main Memory)。當多個處理器的運算任務都涉及同一塊主內存區域時，將可能導致各自的緩存數據不一致。爲此，需要各個處理器訪問緩存時都遵循一些協議，在讀寫時要根據協議進行操作，來維護緩存的一致性。

代碼亂序執行優化問題

爲了使得處理器內部的運算單元儘量被充分利用，提高運算效率，處理器可能會對輸入的代碼進行亂序執行，處理器會在計算之後將亂序執行的結果重組，亂序優化可以保證在單線程下該執行結果與順序執行的結果是一致的，但不保證程序中各個語句計算的先後順序與輸入代碼中的順序一致。

亂序執行技術是處理器爲提高運算速度而做出違背代碼原有順序的優化。在單核時代，處理器保證做出的優化不會導致執行結果遠離預期目標，但在多核環境下卻並非如此。

多核環境下，如果存在一個核的計算任務依賴另一個核計的算任務的中間結果，而且對相關數據讀寫沒做任何防護措施，那麼其順序性並不能靠代碼的先後順序來保證，處理器最終得出的結果和我們邏輯得到的結果可能會大不相同。

以上圖爲例進行說明：CPU的core2中的邏輯B依賴core1中的邏輯A先執行

正常情況下，邏輯A執行完之後再執行邏輯B。
在處理器亂序執行優化情況下，有可能導致flag提前被設置爲true，導致邏輯B先於邏輯A執行。

二， Java內存模型的組成分析

內存模型概念

爲了更好解決上面提到系列問題，內存模型被總結提出，我們可以把內存模型理解爲在特定操作協議下，對特定的內存或高速緩存進行讀寫訪問的過程抽象。

不同架構的物理計算機可以有不一樣的內存模型，Java虛擬機也有自己的內存模型。Java虛擬機規範中試圖定義一種Java內存模型（Java Memory Model，簡稱JMM）來屏蔽掉各種硬件和操作系統的內存訪問差異，以實現讓Java程序在各種平臺下都能達到一致的內存訪問效果，不必因爲不同平臺上的物理機的內存模型的差異，對各平臺定製化開發程序。

更具體一點說，Java內存模型提出目標在於，定義程序中各個變量的訪問規則，即在虛擬機中將變量存儲到內存和從內存中取出變量這樣的底層細節。此處的變量(Variables)與Java編程中所說的變量有所區別，它包括了實例字段、靜態字段和構成數值對象的元素，但不包括局部變量與方法參數，因爲後者是線程私有的。(如果局部變量是一個reference類型，它引用的對象在Java堆中可被各個線程共享，但是reference本身在Java棧的局部變量表中，它是線程私有的)。

Java內存模型的組成

主內存 Java內存模型規定了所有變量都存儲在主內存(Main Memory)中（此處的主內存與介紹物理硬件的主內存名字一樣，兩者可以互相類比，但此處僅是虛擬機內存的一部分）。
工作內存每條線程都有自己的工作內存(Working Memory，又稱本地內存，可與前面介紹的處理器高速緩存類比)，線程的工作內存中保存了該線程使用到的變量的主內存中的共享變量的副本拷貝。工作內存是 JMM 的一個抽象概念，並不真實存在。它涵蓋了緩存，寫緩衝區，寄存器以及其他的硬件和編譯器優化。

Java內存模型抽象示意圖如下：

JVM內存操作的併發問題

結合前面介紹的物理機的處理器處理內存的問題，可以類比總結出JVM內存操作的問題，下面介紹的Java內存模型的執行處理將圍繞解決這2個問題展開：

1 工作內存數據一致性 各個線程操作數據時會保存使用到的主內存中的共享變量副本，當多個線程的運算任務都涉及同一個共享變量時，將導致各自的的共享變量副本不一致，如果真的發生這種情況，數據同步回主內存以誰的副本數據爲準？ Java內存模型主要通過一系列的數據同步協議、規則來保證數據的一致性，後面再詳細介紹。
2 指令重排序優化 Java中重排序通常是編譯器或運行時環境爲了優化程序性能而採取的對指令進行重新排序執行的一種手段。重排序分爲兩類：編譯期重排序和運行期重排序，分別對應編譯時和運行時環境。同樣的，指令重排序不是隨意重排序，它需要滿足以下兩個條件：
- 1 在單線程環境下不能改變程序運行的結果即時編譯器（和處理器）需要保證程序能夠遵守 as-if-serial 屬性。通俗地說，就是在單線程情況下，要給程序一個順序執行的假象。即經過重排序的執行結果要與順序執行的結果保持一致。
- 2 存在數據依賴關係的不允許重排序

多線程環境下，如果線程處理邏輯之間存在依賴關係，有可能因爲指令重排序導致運行結果與預期不同，後面再展開Java內存模型如何解決這種情況。

三，Java內存間的交互操作

在理解Java內存模型的系列協議、特殊規則之前，我們先理解Java中內存間的交互操作。

交互操作流程

爲了更好理解內存的交互操作，以線程通信爲例，我們看看具體如何進行線程間值的同步：

線程1和線程2都有主內存中共享變量x的副本，初始時，這3個內存中x的值都爲0。線程1中更新x的值爲1之後同步到線程2主要涉及2個步驟：

1 線程1把線程工作內存中更新過的x的值刷新到主內存中
2 線程2到主內存中讀取線程1之前已更新過的x變量

從整體上看，這2個步驟是線程1在向線程2發消息，這個通信過程必須經過主內存。線程對變量的所有操作（讀取，賦值）都必須在工作內存中進行。不同線程之間也無法直接訪問對方工作內存中的變量，線程間變量值的傳遞均需要通過主內存來完成，實現各個線程提供共享變量的可見性。

內存交互的基本操作

關於主內存與工作內存之間的具體交互協議，即一個變量如何從主內存拷貝到工作內存、如何從工作內存同步回主內存之類的實現細節，Java內存模型中定義了下面介紹8種操作來完成。

虛擬機實現時必須保證下面介紹的每種操作都是原子的，不可再分的(對於double和long型的變量來說，load、store、read、和write操作在某些平臺上允許有例外，後面會介紹）。

8種基本操作

lock (鎖定) 作用於主內存的變量，它把一個變量標識爲一條線程獨佔的狀態。
unlock (解鎖) 作用於主內存的變量，它把一個處於鎖定狀態的變量釋放出來，釋放後的變量纔可以被其他線程鎖定。
read (讀取) 作用於主內存的變量，它把一個變量的值從主內存傳輸到線程的工作內存中，以便隨後的load動作使用。
load (載入) 作用於工作內存的變量，它把read操作從主內存中得到的變量值放入工作內存的變量副本中。
use (使用) 作用於工作內存的變量，它把工作內存中一個變量的值傳遞給執行引擎，每當虛擬機遇到一個需要使用到變量的值得字節碼指令時就會執行這個操作。
assign (賦值) 作用於工作內存的變量，它把一個從執行引擎接收到的值賦給工作內存的變量，每當虛擬機遇到一個給變量賦值的字節碼指令時執行這個操作。
store (存儲) 作用於工作內存的變量，它把工作內存中一個變量的值傳送到主內存中，以便隨後write操作使用。
write (寫入) 作用於主內存的變量，它把store操作從工作內存中得到的變量的值放入主內存的變量中。

四，Java內存模型運行規則

4.1 內存交互基本操作的3個特性

在介紹內存的交互的具體的8種基本操作之前，有必要先介紹一下操作的3個特性，Java內存模型是圍繞着在併發過程中如何處理這3個特性來建立的，這裏先給出定義和基本實現的簡單介紹，後面會逐步展開分析。

原子性(Atomicity) 即一個操作或者多個操作要麼全部執行並且執行的過程不會被任何因素打斷，要麼就都不執行。即使在多個線程一起執行的時候，一個操作一旦開始，就不會被其他線程所幹擾。
可見性(Visibility) 是指當多個線程訪問同一個變量時，一個線程修改了這個變量的值，其他線程能夠立即看得到修改的值。正如上面“交互操作流程”中所說明的一樣，JMM是通過在線程1變量工作內存修改後將新值同步回主內存，線程2在變量讀取前從主內存刷新變量值，這種依賴主內存作爲傳遞媒介的方式來實現可見性。
有序性(Ordering) 有序性規則表現在以下兩種場景: 線程內和線程間
- 線程內從某個線程的角度看方法的執行，指令會按照一種叫“串行”（as-if-serial）的方式執行，此種方式已經應用於順序編程語言。
- 線程間這個線程“觀察”到其他線程併發地執行非同步的代碼時，由於指令重排序優化，任何代碼都有可能交叉執行。唯一起作用的約束是：對於同步方法，同步塊(synchronized關鍵字修飾)以及volatile字段的操作仍維持相對有序。

Java內存模型的一系列運行規則看起來有點繁瑣，但總結起來，是圍繞原子性、可見性、有序性特徵建立。歸根究底，是爲實現共享變量的在多個線程的工作內存的數據一致性，多線程併發，指令重排序優化的環境中程序能如預期運行。

4.2 happens-before關係

介紹系列規則之前，首先了解一下happens-before關係：用於描述下2個操作的內存可見性：如果操作A happens-before 操作B，那麼A的結果對B可見。happens-before關係的分析需要分爲單線程和多線程的情況：

單線程下的 happens-before 字節碼的先後順序天然包含happens-before關係：因爲單線程內共享一份工作內存，不存在數據一致性的問題。在程序控制流路徑中靠前的字節碼 happens-before 靠後的字節碼，即靠前的字節碼執行完之後操作結果對靠後的字節碼可見。然而，這並不意味着前者一定在後者之前執行。實際上，如果後者不依賴前者的運行結果，那麼它們可能會被重排序。
多線程下的 happens-before 多線程由於每個線程有共享變量的副本，如果沒有對共享變量做同步處理，線程1更新執行操作A共享變量的值之後，線程2開始執行操作B，此時操作A產生的結果對操作B不一定可見。

爲了方便程序開發，Java內存模型實現了下述支持happens-before關係的操作：

程序次序規則一個線程內，按照代碼順序，書寫在前面的操作 happens-before 書寫在後面的操作。
鎖定規則一個unLock操作 happens-before 後面對同一個鎖的lock操作。
volatile變量規則對一個變量的寫操作 happens-before 後面對這個變量的讀操作。
傳遞規則如果操作A happens-before 操作B，而操作B又 happens-before 操作C，則可以得出操作A happens-before 操作C。
線程啓動規則 Thread對象的start()方法 happens-before 此線程的每個一個動作。
線程中斷規則對線程interrupt()方法的調用 happens-before 被中斷線程的代碼檢測到中斷事件的發生。
線程終結規則線程中所有的操作都 happens-before 線程的終止檢測，我們可以通過Thread.join()方法結束、Thread.isAlive()的返回值手段檢測到線程已經終止執行。
對象終結規則一個對象的初始化完成 happens-before 他的finalize()方法的開始

4.3 內存屏障

Java中如何保證底層操作的有序性和可見性？可以通過內存屏障。

內存屏障是被插入兩個CPU指令之間的一種指令，用來禁止處理器指令發生重排序（像屏障一樣），從而保障有序性的。另外，爲了達到屏障的效果，它也會使處理器寫入、讀取值之前，將主內存的值寫入高速緩存，清空無效隊列，從而保障可見性。

舉個例子：

Store1; 
Store2;   
Load1;   
StoreLoad;  //內存屏障
Store3;   
Load2;   
Load3;

對於上面的一組CPU指令（Store表示寫入指令，Load表示讀取指令），StoreLoad屏障之前的Store指令無法與StoreLoad屏障之後的Load指令進行交換位置，即重排序。但是StoreLoad屏障之前和之後的指令是可以互換位置的，即Store1可以和Store2互換，Load2可以和Load3互換。

常見有4種屏障

LoadLoad屏障：對於這樣的語句 Load1; LoadLoad; Load2，在Load2及後續讀取操作要讀取的數據被訪問前，保證Load1要讀取的數據被讀取完畢。
StoreStore屏障：對於這樣的語句 Store1; StoreStore; Store2，在Store2及後續寫入操作執行前，保證Store1的寫入操作對其它處理器可見。
LoadStore屏障：對於這樣的語句Load1; LoadStore; Store2，在Store2及後續寫入操作被執行前，保證Load1要讀取的數據被讀取完畢。
StoreLoad屏障：對於這樣的語句Store1; StoreLoad; Load2，在Load2及後續所有讀取操作執行前，保證Store1的寫入對所有處理器可見。它的開銷是四種屏障中最大的（沖刷寫緩衝器，清空無效化隊列）。在大多數處理器的實現中，這個屏障是個萬能屏障，兼具其它三種內存屏障的功能。

Java中對內存屏障的使用在一般的代碼中不太容易見到，常見的有volatile和synchronized關鍵字修飾的代碼塊(後面再展開介紹)，還可以通過Unsafe這個類來使用內存屏障。

4.4 8種操作同步的規則

JMM在執行前面介紹8種基本操作時，爲了保證內存間數據一致性，JMM中規定需要滿足以下規則：

規則1：如果要把一個變量從主內存中複製到工作內存，就需要按順序的執行 read 和 load 操作，如果把變量從工作內存中同步回主內存中，就要按順序的執行 store 和 write 操作。但 Java 內存模型只要求上述操作必須按順序執行，而沒有保證必須是連續執行。
規則2：不允許 read 和 load、store 和 write 操作之一單獨出現。
規則3：不允許一個線程丟棄它的最近 assign 的操作，即變量在工作內存中改變了之後必須同步到主內存中。
規則4：不允許一個線程無原因的（沒有發生過任何 assign 操作）把數據從工作內存同步回主內存中。
規則5：一個新的變量只能在主內存中誕生，不允許在工作內存中直接使用一個未被初始化（load 或 assign ）的變量。即就是對一個變量實施 use 和 store 操作之前，必須先執行過了 load 或 assign 操作。
規則6：一個變量在同一個時刻只允許一條線程對其進行 lock 操作，但 lock 操作可以被同一條線程重複執行多次，多次執行 lock 後，只有執行相同次數的 unlock 操作，變量纔會被解鎖。所以 lock 和 unlock 必須成對出現。
規則7：如果對一個變量執行 lock 操作，將會清空工作內存中此變量的值，在執行引擎使用這個變量前需要重新執行 load 或 assign 操作初始化變量的值。
規則8：如果一個變量事先沒有被 lock 操作鎖定，則不允許對它執行 unlock 操作；也不允許去 unlock 一個被其他線程鎖定的變量。
規則9：對一個變量執行 unlock 操作之前，必須先把此變量同步到主內存中（執行 store 和 write 操作）

看起來這些規則有些繁瑣，其實也不難理解：

規則1、規則2 工作內存中的共享變量作爲主內存的副本，主內存變量的值同步到工作內存需要read和load一起使用，工作內存中的變量的值同步回主內存需要store和write一起使用，這2組操作各自都是是一個固定的有序搭配，不允許單獨出現。
規則3、規則4 由於工作內存中的共享變量是主內存的副本，爲保證數據一致性，當工作內存中的變量被字節碼引擎重新賦值，必須同步回主內存。如果工作內存的變量沒有被更新，不允許無原因同步回主內存。
規則5 由於工作內存中的共享變量是主內存的副本，必須從主內存誕生。
規則6、7、8、9 爲了併發情況下安全使用變量，線程可以基於lock操作獨佔主內存中的變量，其他線程不允許使用或unlock該變量，直到變量被線程unlock。

4.5 volatile型變量的特殊規則

volatile的中文意思是不穩定的，易變的，用volatile修飾變量是爲了保證變量的可見性。

volatile的語義

volatile主要有下面2種語義

語義1 保證可見性

保證了不同線程對該變量操作的內存可見性。

這裏保證可見性是不等同於volatile變量併發操作的安全性，保證可見性具體一點解釋：

線程寫volatile變量的過程：

1 改變線程工作內存中volatile變量副本的值
2 將改變後的副本的值從工作內存刷新到主內存

線程讀volatile變量的過程：

1 從主內存中讀取volatile變量的最新值到線程的工作內存中
2 從工作內存中讀取volatile變量的副本

但是如果多個線程同時把更新後的變量值同時刷新回主內存，可能導致得到的值不是預期結果：

舉個例子：定義volatile int count = 0，2個線程同時執行count++操作，每個線程都執行500次，最終結果小於1000，原因是每個線程執行count++需要以下3個步驟：

步驟1 線程從主內存讀取最新的count的值
步驟2 執行引擎把count值加1，並賦值給線程工作內存
步驟3 線程工作內存把count值保存到主內存有可能某一時刻2個線程在步驟1讀取到的值都是100，執行完步驟2得到的值都是101，最後刷新了2次101保存到主內存。

語義2 禁止進行指令重排序

具體一點解釋，禁止重排序的規則如下：

當程序執行到 volatile變量的讀操作或者寫操作時，在其前面的操作的更改肯定全部已經進行，且結果已經對後面的操作可見；在其後面的操作肯定還沒有進行；
在進行指令優化時，不能將在對 volatile 變量訪問的語句放在其後面執行，也不能把 volatile 變量後面的語句放到其前面執行。

普通的變量僅僅會保證該方法的執行過程中所有依賴賦值結果的地方都能獲取到正確的結果，而不能保證賦值操作的順序與程序代碼中的執行順序一致。

舉個例子：

volatile boolean initialized = false;

// 下面代碼線程A中執行
// 讀取配置信息，當讀取完成後將initialized設置爲true以通知其他線程配置可用
doSomethingReadConfg();
initialized = true;

// 下面代碼線程B中執行
// 等待initialized 爲true，代表線程A已經把配置信息初始化完成
while (!initialized) {
     sleep();
}
// 使用線程A初始化好的配置信息
doSomethingWithConfig();

上面代碼中如果定義initialized變量時沒有使用volatile修飾，就有可能會由於指令重排序的優化，導致線程A中最後一句代碼 "initialized = true" 在 “doSomethingReadConfg()” 之前被執行，這樣會導致線程B中使用配置信息的代碼就可能出現錯誤，而volatile關鍵字就禁止重排序的語義可以避免此類情況發生。

volatile型變量實現原理

具體實現方式是在編譯期生成字節碼時，會在指令序列中增加內存屏障來保證，下面是基於保守策略的JMM內存屏障插入策略：

在每個volatile寫操作的前面插入一個StoreStore屏障。該屏障除了保證了屏障之前的寫操作和該屏障之後的寫操作不能重排序，還會保證了volatile寫操作之前，任何的讀寫操作都會先於volatile被提交。
在每個volatile寫操作的後面插入一個StoreLoad屏障。該屏障除了使volatile寫操作不會與之後的讀操作重排序外，還會刷新處理器緩存，使volatile變量的寫更新對其他線程可見。
在每個volatile讀操作的後面插入一個LoadLoad屏障。該屏障除了使volatile讀操作不會與之前的寫操作發生重排序外，還會刷新處理器緩存，使volatile變量讀取的爲最新值。
在每個volatile讀操作的後面插入一個LoadStore屏障。該屏障除了禁止了volatile讀操作與其之後的任何寫操作進行重排序，還會刷新處理器緩存，使其他線程volatile變量的寫更新對volatile讀操作的線程可見。

volatile型變量使用場景

總結起來，就是“一次寫入，到處讀取”，某一線程負責更新變量，其他線程只讀取變量(不更新變量)，並根據變量的新值執行相應邏輯。例如狀態標誌位更新，觀察者模型變量值發佈。

4.6 final型變量的特殊規則

我們知道，final成員變量必須在聲明的時候初始化或者在構造器中初始化，否則就會報編譯錯誤。 final關鍵字的可見性是指：被final修飾的字段在聲明時或者構造器中，一旦初始化完成，那麼在其他線程無須同步就能正確看見final字段的值。這是因爲一旦初始化完成，final變量的值立刻回寫到主內存。

4.7 synchronized的特殊規則

通過 synchronized關鍵字包住的代碼區域，對數據的讀寫進行控制：

讀數據當線程進入到該區域讀取變量信息時，對數據的讀取也不能從工作內存讀取，只能從內存中讀取，保證讀到的是最新的值。
寫數據在同步區內對變量的寫入操作，在離開同步區時就將當前線程內的數據刷新到內存中，保證更新的數據對其他線程的可見性。

4.8 long和double型變量的特殊規則

Java內存模型要求lock、unlock、read、load、assign、use、store、write這8種操作都具有原子性，但是對於64位的數據類型(long和double)，在模型中特別定義相對寬鬆的規定：允許虛擬機將沒有被volatile修飾的64位數據的讀寫操作分爲2次32位的操作來進行。也就是說虛擬機可選擇不保證64位數據類型的load、store、read和write這4個操作的原子性。由於這種非原子性，有可能導致其他線程讀到同步未完成的“32位的半個變量”的值。

不過實際開發中，Java內存模型強烈建議虛擬機把64位數據的讀寫實現爲具有原子性，目前各種平臺下的商用虛擬機都選擇把64位數據的讀寫操作作爲原子操作來對待，因此我們在編寫代碼時一般不需要把用到的long和double變量專門聲明爲volatile。

5 總結

由於Java內存模型涉及系列規則，網上的文章大部分就是對這些規則進行解析，但是很多沒有解釋爲什麼需要這些規則，這些規則的作用，其實這是不利於初學者學習的，容易繞進去這些繁瑣規則不知所以然，下面談談我的一點學習知識的個人體會：

學習知識的過程不是等同於只是理解知識和記憶知識，而是要對知識解決的問題的輸入和輸出建立連接，知識的本質是解決問題，所以在學習之前要理解問題，理解這個問題要的輸出和輸出，而知識就是輸入到輸出的一個關係映射。知識的學習要結合大量的例子來理解這個映射關係，然後壓縮知識，華羅庚說過：“把一本書讀厚，然後再讀薄”，解釋的就是這個道理，先結合大量的例子理解知識，然後再壓縮知識。

以學習Java內存模型爲例：

理解問題，明確輸入輸出首先理解Java內存模型是什麼，有什麼用，解決什麼問題
理解內存模型系列協議結合大量例子理解這些協議規則
壓縮知識大量規則其實就是通過數據同步協議，保證內存副本之間的數據一致性，同時防止重排序對程序的影響。

參考

《深入學習Java虛擬機》

深入拆解Java虛擬機

Java核心技術36講

Synchronization and the Java Memory Model ——Doug Lea

深入理解 Java 內存模型

Java內存屏障和可見性

內存屏障與synchronized、volatile的原理

深入理解java內存模型