一、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防止發生指令重排。----超高併發下的應用。