volatile
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又保證了可見性，所以就保證了執行緒安全。
