一、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保證每個時刻是有一個執行緒執行同步代碼，相當于是讓執行緒順序執行同步代碼，自然就保證了有序性，
指令重排序：java語言規范規定JVM執行緒內部維持順序化語意，即只要程式的最終結果與它順序化情況的結果相等，那么指令的執行順序可以與代碼順序不一致，此程序叫指令的重排序，指令重排序的意義是什么？JVM能根據處理器特性（CPU多級快取系統、多核處理器等）適當的對機器指令進行重排序，使機器指令能更符合CPU的執行特性，最大限度的發揮機器性能 as-if-serial語意的意思是：不管怎么重排序（編譯器和處理器為了提高并行度），（單執行緒）程式的執行結果不能被改變，編譯器、runtime和處理器都必須遵守as-if-serial語意，為了遵守as-if-serial語意，編譯器和處理器不會對存在資料依賴關系的操作做重排序，因為這種重排序會改變執行結果，但是，如果操作之間不存在資料依賴關系，這些操作就可能被編譯器和處理器重排序，也就是說指令重排只能保證單執行緒沒有問題，不能保證多執行緒安全，指令從排序發生在編譯重排序和處理器重排序，禁止指令重排序的底層就是記憶體屏障，記憶體屏障分為4種
1、StoreStore 2、StoreLoad 3、LoadLoad 4、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讀，第二步再普通寫 } });
六、總線風暴問題
大量使用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防止發生指令重排，----超高并發下的應用，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/145704.html
標籤：Java