JMM（java記憶體模型）
-
JMM屏蔽了底層不同計算機的區別，描述了Java程式中執行緒共享變數的訪問規則，以及在jvm中將變數存盤到記憶體和從記憶體中讀取變數這樣的底層細節，
-
JMM有以下規定：
-
所有的共享變數都存盤與主記憶體中，這里所說的變數指的是實體變數和類變數，不包含區域變數，因為區域變數是執行緒私有的，因此不存在競爭問題，
-
每一個執行緒還存在自己的作業記憶體，執行緒的作業記憶體，保留了被執行緒使用的變數的作業副本，
-
執行緒對變數的所有操作（讀和寫）都必須在作業記憶體中完成，而不能直接讀寫主記憶體中的變數，
-
不同執行緒之間也不能直接訪問對方作業記憶體中的變數，執行緒間變數的值傳遞需要通過主記憶體中轉來完成，
-
多執行緒下變數的不可見性：
public class test7 {
public static void main(String[] args) {
MyThread t = new MyThread();
t.start();
while (true) {
if (t.isFlag()) {
System.out.println("停不下來了"); // 不會執行到這里
}
}
}
}
class MyThread extends Thread {
private boolean flag = false;
// private volatile boolean flag = false;
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
flag = true;
System.out.println("flag被修改了");
}
public boolean isFlag() {
return flag;
}
}
原因：
- 子執行緒t從主記憶體讀取到資料放入其對應的作業記憶體
- 將flag的值更改為true，但flag的值還沒有寫回主記憶體
- 此時main方法讀取到了flag的值為false
- 當子執行緒t將flag的值寫回主記憶體后，主執行緒沒有再去讀取主記憶體中的值，所以while(true)讀取到的值一直是false，
volatile 的特性
-
volite 可以實作并發下共享變數的可見性；
-
volite 不保證原子性；
-
volite 可以防止指令重排序的操作，
使用原子類來保證原子性：
public AtomicInteger()： 初始化一個默認值為0的原子型Integer public AtomicInteger(int initialValue)： 初始化一個指定值的原子型 Integer int get(): 獲取值 int getAndIncrement(): 以原子方式將當前值加1，注意，這里回傳的是自增前的值， int incrementAndGet(): 以原子方式將當前值加1，注意，這里回傳的是自增后的值， int addAndGet(int data): 以原子方式將輸入的數值與實體中的值（AtomicInteger里的 value）相加，并回傳結果， int getAndSet(int value): 以原子方式設定為newValue的值，并回傳舊值private static AtomicInteger atomicInteger = new AtomicInteger(); Runnable r = () -> { for (int i = 0; i < 100; i++) { atomicInteger.incrementAndGet(); } };有時為了提高性能，編譯器和處理器常常會對既定的代碼執行順序進行指令重排序，重排序可以提高處理的速度，
volatile寫讀建立的happens-before關系
happens-before ：前一個操作的結果可以被后續的操作獲取，
happens-before規則：
-
程式順序規則（單執行緒規則）
同一個執行緒中前面的所有寫操作對后面的操作可見
-
鎖規則（Synchronized,Lock等）
如果執行緒1解鎖了monitor a，接著執行緒2鎖定了a，那么，執行緒1解鎖a之前的寫操作都對執行緒2可見（執行緒
1和執行緒2可以是同一個執行緒）
-
volatile變數規則：
如果執行緒1寫入了volatile變數v（臨界資源），接著執行緒2讀取了v，那么，執行緒1寫入v及之前的寫操作都
對執行緒2可見（執行緒1和執行緒2可以是同一個執行緒）
-
傳遞性：
A h-b B ， B h-b C 那么可以得到 A h-b C
-
join()規則：
執行緒t1寫入的所有變數，在任意其它執行緒t2呼叫t1.join()，或者t1.isAlive() 成功回傳后，都對t2可見，
-
start()規則：
假定執行緒A在執行程序中，通過執行ThreadB.start()來啟動執行緒B，那么執行緒A對共享變數的修改在接下來
執行緒B開始執行前對執行緒B可見，注意：執行緒B啟動之后，執行緒A在對變數修改執行緒B未必可見，
public class VisibilityHP {
int a = 1;
int b = 2;
private void write() {
a = 3;
b = a;
}
private void read() {
System.out.println("b=" + b + ";a=" + a);
}
public static void main(String[] args) {
while (true) {
VisibilityHP test = new VisibilityHP();
new Thread(new Runnable() {
@Override
public void run() {
test.write();
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
test.read();
}
}).start();
}
}
}
沒給b加volatile,那么有可能出現a=1 , b = 3 ，因為a雖然被修改了，但是其他執行緒不可見，而b恰好其他執行緒可見，造成了b=3 , a=1，
如果使用volatile修飾long和double，那么其讀寫都是原子操作
volatile在雙重檢查加鎖的單例中的應用
餓漢式（靜態常量）
public class Singleton01 {
private static final Singleton01 Intance = new Singleton01();
private Singleton01() {}
public static Singleton01 getIntance() {
return Intance;
}
}
餓漢式（靜態代碼塊）
public class Singleton02 {
private final static Singleton02 Intance;
static {
Intance = new Singleton02();
}
private Singleton02() {}
public static Singleton02 getInstance() {
return Intance;
}
}
懶漢式（執行緒安全，性能差）
public class Singleton03 {
private static Singleton03 Instance;
private Singleton03() {}
public static synchronized Singleton03 getInstance() {
if (Instance == null) {
Instance = new Singleton03();
}
return Instance;
}
}
懶漢式（volatile雙重檢查模式,推薦）
public class Singleton04 {
private static volatile Singleton04 Instance = null;
private Singleton04() {}
public static Singleton04 getInstance() {
if (Instance == null) {
synchronized (Singleton04.class) {
if (Instance == null) {
//創建物件的程序是非原子操作
Instance = new Singleton04();
}
}
}
return Instance;
}
}
此處加上volatile 的作用：
① 禁止指令重排序，
創建物件的程序要經過以下幾個步驟s：
a. 分配記憶體空間
b. 呼叫構造器，初始化實體
c. 回傳地址給參考
原因：由于創建物件是一個非原子操作，編譯器可能會重排序，即只是在記憶體中開辟一片存盤空間后直接回傳記憶體的參考，而下一個執行緒在判斷 instance 時就不為null 了，但此時該執行緒只是拿到了沒有初始化完成的物件，該執行緒可能會繼續拿著這個沒有初始化的物件繼續進行操作，容易觸發“NPE 例外”，
② 保證可見性
靜態內部類單例方式
public class Singleton05 {
private Singleton05() {}
private static class SingletonInstance {
private static final Singleton05 INSTANCE = new Singleton05();
}
public static Singleton05 getInstance() {
return SingletonInstance.INSTANCE;
}
}
- 靜態內部類只有在呼叫時才會被加載，jvm在底層會保證只有一個執行緒去初始化實體，下一個執行緒獲取實體時就直接回傳，
- 相比于雙重檢查，靜態內部類的代碼更簡潔，但基于volatile的雙重檢查有一個額外的優勢：除了可以對靜態欄位實作延遲加載初始化外，還可以對實體欄位實作延遲初始化，
volatile使用場景
-
volatile適合做多執行緒中的純賦值操作：如果一個共享變數自始至終只被各個執行緒賦值，而沒有其他操作，那么可以用volatile來代替synchronized，因為賦值操作本身是原子性的，而volatile又保證了可見性，所以足以保證執行緒安全，
-
volatile可以作為重繪之前變數的觸發器，可以將某個變數設定為volatile修飾，其他執行緒一旦發現該變數修改的值后，觸發獲取到該變數之前的操作都將是最新可見的，
public class test8 { int a = 1; int b = 2; int c = 3; volatile boolean flag = false; public void write() { a = 100; b = 200; c = 300; flag = true; } public void read() { while (flag) { System.out.println("a=" + a + " " + "b=" + b + " " + "c=" + c); break; } } public static void main(String[] args) { test8 test8 = new test8(); new Thread(() -> { test8.write(); }).start(); new Thread(() -> { test8.read(); }).start(); } }
volatile 和synchronized的區別
- volatile只能修飾實體變數和類變數，而synchronized可以修飾方法，以及代碼塊，
- volatile保證資料的可見性，但是不保證原子性，不保證執行緒安全，
- volatile可以禁止指令重排序，解決單例雙重檢查物件初始化代碼執行亂序問題，
- volatile可以看做輕量版synchronized，volatile不保證原子性，但是如果對一個共享變數只進行純賦值操作，而沒有其他操作，那么可以使用volatile來代替synchronized，因為賦值本身是有原子性的，而volatile又保證了可見性，所以就保證了執行緒安全，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/226353.html
標籤：其他
上一篇：ThreadPoolExecutor原始碼分析-面試問爛了的Java執行緒池執行流程，如果要問你具體的執行細節，你還會嗎？
下一篇：ThreadPoolExecutor原始碼分析-面試問爛了的Java執行緒池執行流程，如果要問你具體的執行細節，你還會嗎？