併發編程之volatile

1、Java內存模型內存交互操做

一、lock(鎖定)：做用於主內存的變量，把一個變量標記爲一條線程獨佔狀態

二、unlock(解鎖)：做用於主內存的變量，把一個處於鎖定狀態的變量釋放出來，釋放後的變量才能夠被其餘線程鎖定

三、read(讀取)：做用於主內存的變量，把一個變量值從主內存傳輸到線程的工做內存中，以便隨後的load動做使用

四、load(載入)：做用於工做內存的變量，它把read操做從主內存中獲得的變量值放入工做內存的變量副本中

五、use(使用)：做用於工做內存的變量，把工做內存中的一個變量值傳遞給執行引擎

六、assign(賦值)：做用於工做內存的變量，它把一個從執行引擎接收到的值賦給工做內存的變量

七、store(存儲)：做用於工做內存的變量，把工做內存中的一個變量的值傳送到主內存中，以便隨後的write的操做

八、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）這一步若是沒有用緩存一致性協議，會有延時不會當即寫到主內存，參考第一篇緩存一執行性協議講解。

2、volatile原理與內存語義

volatile是Java虛擬機提供的輕量級的同步機制

volatile語義有以下兩個做用

可見性：保證被volatile修飾的共享變量對全部線程總數可見的，也就是當一個線程修改了一個被volatile修飾共享變量的值，新值老是能夠被其餘線程當即得知。

有序性：禁止指令重排序優化。

volatile緩存可見性實現原理

JMM內存交互層面：volatile修飾的變量的read、load、use操做和assign、store、write必須是連續的，即修改後必須當即同步會主內存，使用時必須從主內存刷新，由此保證volatile變量的可見性。 底層實現：經過彙編lock前綴指令，它會鎖定變量緩存行區域並寫回主內存，這個操做稱爲「緩存鎖定」，緩存一致性機制會阻止同時修改被兩個以上處理器緩存的內存區域數據。一個處理器的緩存回寫到內存內存會致使其餘處理器的緩存無效

3、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中原來地緩存失效，從主內存中從新讀取新值。

4、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，只有一個有效，最後結果比預期結果小。

5、volatile保證有序性防止指令重排

有序性問題

 在Java裏面，能夠經過volatile關鍵字來保證必定的「有序性」（具體原理在下一節講述volatile關鍵字）。另外能夠經過synchronized和Lock來保證有序性，很顯然，synchronized和Lock保證每一個時刻是有一個線程執行同步代碼，至關因而讓線程順序執行同步代碼，天然就保證了有序性。

指令重排序：java語言規範規定JVM線程內部維持順序化語義。即只要程序的最終結果與它順序化狀況的結果相等，那麼指令的執行順序能夠與代碼順序不一致，此過程叫指令的重排序。指令重排序的意義是什麼？JVM能根據處理器特性（CPU多級緩存系統、多核處理器等）適當的對機器指令進行重排序，使機器指令能更符合CPU的執行特性，最大限度的發揮機器性能

 

as-if-serial語義的意思是：無論怎麼重排序（編譯器和處理器爲了提升並行度），（單線程）程序的執行結果不能被改變。編譯器、runtime和處理器都必須遵照as-if-serial語義。爲了遵照as-if-serial語義，編譯器和處理器不會對存在數據依賴關係的操做作重排序，由於這種重排序會改變執行結果。可是，若是操做之間不存在數據依賴關係，這些操做就可能被編譯器和處理器重排序。也就是說指令重排只能保證單線程沒有問題，不能保證多線程安全。

 

指令從排序發生在編譯重排序和處理器重排序，禁止指令重排序的底層就是內存屏障，內存屏障分爲4種

一、StoreStore  二、StoreLoad  三、LoadLoad  四、LoadStore

爲了實現volatile的內存語義，編譯器在生成字節碼時，會在指令序列中插入內存屏障來禁止特定類型的處理器重排序。對於編譯器來講，發現一個最優佈置來最小化插入屏障的總數幾乎不可能。爲此，JMM採起保守策略。下面是基於保守策略的JMM內存屏障插入策略。

（1）∙在每一個volatile寫操做的前面插入一個StoreStore屏障。

（2）在每一個volatile寫操做的後面插入一個StoreLoad屏障。

（3）在每一個volatile讀操做的後面插入一個LoadLoad屏障。

（4）在每一個volatile讀操做的後面插入一個LoadStore屏障。

上述內存屏障插入策略很是保守，但它能夠保證在任意處理器平臺，任意的程序中都能獲得正確的volatile內存語義。

 

小知識點，不用volatile如何防止指令重排：

手動加內存屏障

 public void run() {
                    //因爲線程one先啓動，下面這句話讓它等一等線程two. 讀着可根據本身電腦的實際性能適當調整等待時間.
                    shortWait(10000);
                    a = 1; //是讀仍是寫？store，volatile寫
                    //storeload ,讀寫屏障，不容許volatile寫與第二部volatile讀發生重排
                    //手動加內存屏障
                    UnsafeInstance.reflectGetUnsafe().storeFence();
                    x = b; // 讀仍是寫？讀寫都有，先讀volatile，寫普通變量
                    //分兩步進行，第一步先volatile讀，第二步再普通寫
                }
            });

6、總線風暴問題

大量使用volatile會引發工做緩存有大量的無效緩存，並且volatile會一塊兒會引發線程之間相互監聽，嗅探，這些都會佔用總線資源，致使總線資源負載太高。這時候咱們須要鎖來解決問題，這就是爲何有了

volatile咱們還須要synchronized，lock鎖，由於volatile保證不了原子操做，且用的過多會致使總線風暴。

7、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() 並不時一個原子操做，它能夠分爲三部，一、申請空間，2，實力化對象，3，地址賦值給myinstance 變量，加synchronized 保證了原子操做，可是沒法防止指令重排，線程1申請完空間以後若是發生指令重排直接執行第3步賦值，那麼線程2執行if判斷時myinstance 不爲空可是卻沒有實例化對象。這是指令重排致使的，因此volatile 修飾myinstance防止發生指令重排。----超高併發下的應用。