一、Java記憶體模型記憶體互動操作
1、lock(鎖定)：作用於主記憶體的變數，把一個變數標記為一條執行緒獨佔狀態
2、unlock(解鎖)：作用於主記憶體的變數，把一個處於鎖定狀態的變數釋放出來，釋放後的變數才可以被其他執行緒鎖定
3、read(讀取)：作用於主記憶體的變數，把一個變數值從主記憶體傳輸到執行緒的工作記憶體中，以便隨後的load動作使用
4、load(載入)：作用於工作記憶體的變數，它把read操作從主記憶體中得到的變數值放入工作記憶體的變數副本中
5、use(使用)：作用於工作記憶體的變數，把工作記憶體中的一個變數值傳遞給執行引擎
6、assign(賦值)：作用於工作記憶體的變數，它把一個從執行引擎接收到的值賦給工作記憶體的變數
7、store(儲存)：作用於工作記憶體的變數，把工作記憶體中的一個變數的值傳送到主記憶體中，以便隨後的write的操作
8、write(寫入)：作用於工作記憶體的變數，它把store操作從工作記憶體中的一個變數的值傳送到主記憶體的變數中
整個執行流程如圖
read ---load store----writr必須成對執行
通過上面分析我們可以看出即使在java裡面執行i++這樣的操作，對於我們的底層來說也不是原子操作，因為i++，也需要將這八大操作走一遍，具體來說，read ---load 將主記憶體中i=0在工作記憶體中也copy一份，
執行緒讀到工作記憶體中的i=0並加1操作即結果i=1寫回工作記憶體（use---assign），然後將i=1寫回主記憶體（store----writrt）這一步如果沒有用快取一致性協議，會有延時不會立即寫到主記憶體，參考第一篇快取一執行性協議講解。
二、volatile原理與記憶體語義
volatile是Java虛擬機器提供的輕量級的同步機制
volatile語義有如下兩個作用
可見性：保證被volatile修飾的共享變數對所有執行緒總數可見的，也就是當一個執行緒修改了一個被volatile修飾共享變數的值，新值總是可以被其他執行緒立即得知。
有序性：禁止指令重排序優化。
volatile快取可見性實現原理
JMM記憶體互動層面：volatile修飾的變數的read、load、use操作和assign、store、write必須是連續的，即修改後必須立即同步會主記憶體，使用時必須從主記憶體重新整理，由此保證volatile變數的可見性。 底層實現：通過彙編lock字首指令，它會鎖定變數快取行區域並寫回主記憶體，這個操作稱為“快取鎖定”，快取一致性機制會阻止同時修改被兩個以上處理器快取的記憶體區域資料。一個處理器的快取回寫到記憶體記憶體會導致其他處理器的快取無效
三、volatile可見性分析
先上一段程式碼：
public class VolatileVisibilitySample { private boolean initFlag = false; static Object object = new Object(); public void refresh(){ this.initFlag = true; //普通寫操作，(volatile寫) String threadname = Thread.currentThread().getName(); System.out.println("執行緒："+threadname+":修改共享變數initFlag"); } public void load(){ String threadname = Thread.currentThread().getName(); int i = 0; while (!initFlag){ } System.out.println("執行緒："+threadname+"當前執行緒嗅探到initFlag的狀態的改變"+i); } public static void main(String[] args){ VolatileVisibilitySample sample = new VolatileVisibilitySample(); Thread threadA = new Thread(()->{ sample.refresh(); },"threadA"); Thread threadB = new Thread(()->{ sample.load(); },"threadB"); threadB.start(); try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } threadA.start(); } }
程式碼很好理解，執行緒B讀取成員變數initFlag 如果為false無線迴圈，如果為true,打出表示語，執行緒A負責將initFlag改為true，執行緒B先啟動，執行緒A啟動修改標誌為true後，看看執行緒B能否感知到並終止迴圈
測試結果 ：執行緒B無線迴圈，未能感知到標誌被執行緒A修改，原因，執行緒B一直讀的是工作空間的快取資料，當執行緒A修改資料之後，執行緒B未能感知到.
降上訴程式碼修改，執行緒B的執行任務上加鎖synchronized：
public void load(){ String threadname = Thread.currentThread().getName(); int i = 0; while (!initFlag){ synchronized (object){ i++; } } System.out.println("執行緒："+threadname+"當前執行緒嗅探到initFlag的狀態的改變"+i); }
測試結果：加鎖會導致執行緒B失去cpu執行權，當再次獲取cpu執行權時，會引起執行緒上下文切換，這個過程會引起重新讀取主記憶體資料。
volatile關鍵字測試
initFlag用volatile修飾後
private volatile boolean initFlag = false;
測試結果：當執行緒A修改initFlag後執行緒B能立即感知到，停止迴圈打出標誌語；
原因：執行緒A修改initFlag，由於initFlag被volatile修飾，會立即從工作記憶體刷到主記憶體，同時讓其他執行緒中工作記憶體中initFlag資料快取失效，這樣執行緒B中原來地快取失效，從主記憶體中重新讀取新值。
四、volatile不能保證原子性
先來一段程式碼：
public class VolatileAtomicSample { private static volatile int counter = 0; public static void main(String[] args) { for (int i = 0; i < 10; i++) { Thread thread = new Thread(()->{ for (int j = 0; j < 1000; j++) { counter++; //不是一個原子操作,第一輪迴圈結果是沒有刷入主存，這一輪迴圈已經無效 //1 load counter 到工作記憶體 //2 add counter 執行自加 //其他的程式碼段？ } }); thread.start(); } try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(counter); } }
開10個執行緒每個執行緒對counter進行1000次+最總我們地結果也不是10000，而是小於10000，
原因：couter++並不是原子操作，比如兩個執行緒讀到counter=0都讀到自己地工作記憶體，然後加1之後都要往我們地主記憶體寫，這時候必然引起裁決，導致一個執行緒的+1有效果，一個執行緒的+1無效果，最後導致
兩個執行緒一共加了兩次1，只有一個有效，最後結果比預期結果小。
五、volatile保證有序性防止指令重排
有序性問題
在Java裡面，可以通過volatile關鍵字來保證一定的“有序性”（具體原理在下一節講述volatile關鍵字）。另外可以通過synchronized和Lock來保證有序性，很顯然，synchronized和Lock保證每個時刻是有一個執行緒執行同步程式碼，相當於是讓執行緒順序執行同步程式碼，自然就保證了有序性。
指令從排序發生在編譯重排序和處理器重排序，禁止指令重排序的底層就是記憶體屏障，記憶體屏障分為4種
1、StoreStore 2、StoreLoad 3、LoadLoad 4、LoadStore
public void run() { //由於執行緒one先啟動，下面這句話讓它等一等執行緒two. 讀著可根據自己電腦的實際效能適當調整等待時間. shortWait(10000); a = 1; //是讀還是寫？store，volatile寫 //storeload ,讀寫屏障，不允許volatile寫與第二部volatile讀發生重排 //手動加記憶體屏障 UnsafeInstance.reflectGetUnsafe().storeFence(); x = b; // 讀還是寫？讀寫都有，先讀volatile，寫普通變數 //分兩步進行，第一步先volatile讀，第二步再普通寫 } });
六、匯流排風暴問題
大量使用volatile會引起工作快取有大量的無效快取，而且volatile會一起會引起執行緒之間相互監聽，嗅探，這些都會佔用匯流排資源，導致匯流排資源負載過高。這時候我們需要鎖來解決問題，這就是為什麼有了
volatile我們還需要synchronized，lock鎖，因為volatile保證不了原子操作，且用的過多會導致匯流排風暴。
七、volatile，synchronized同時使用-----一個超高併發的單例場景
public class Singleton { /** * 檢視彙編指令 * -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp */ private volatile static Singleton myinstance; public static Singleton getInstance() { if (myinstance == null) { synchronized (Singleton.class) { if (myinstance == null) { myinstance = new Singleton();//物件建立過程，本質可以分文三步 //物件延遲初始化 // } } } return myinstance; } public static void main(String[] args) { Singleton.getInstance(); } }
解釋：建立物件myinstance = new Singleton() 並不時一個原子操作，它可以分為三部，1、申請空間，2，實力化物件，3，地址賦值給myinstance 變數，加synchronized 保證了原子操作，但是無法防止指令重排，執行緒1申請完空間之後如果發生指令重排直接執行第3步賦值，那麼執行緒2執行if判斷時myinstance 不為空但是卻沒有例項化物件。這是指令重排導致的，所以volatile 修飾myinstance防止發生指令重排。----超高併發下的應用。