volatile是java虛擬機提供的輕量級的同步機制
1.特性
- 保證可見性
- 不保證原子性
- 禁止指令重排
2. 特性解釋
2.1 可見性：
一個線程操作某個對象，修改了值之后，其余的線程都知道，這就叫可見性
各個線程對主內存中共享變量的操作都是各個線程各自拷貝到自己的工作內存進行操作后再寫回到主內存中的。
這就可能存在一個線程AAA修改了共享變量X的值，但還未寫回主內存時，另外一個線程BBB又對主內存中同一個變量X進行操作，但此時A線程工作內存中共享變量X對線程B來說并不可見
這種工作內存與主內存同步延遲現象就造成了可見性問題
/**
* 1驗證volatile的可見性
* 1.1 如果int num = 0，number變量沒有添加volatile關鍵字修飾
* 1.2 添加了volatile，可以解決可見性
*/
public class VolatileDemo {
public static void main(String[] args) {
visibilityByVolatile();//驗證volatile的可見性
}
/**
* volatile可以保證可見性，及時通知其他線程，主物理內存的值已經被修改
*/
public static void visibilityByVolatile() {
MyData myData = new MyData();
//第一個線程
new Thread(() -> {
System.out.println(Thread.currentThread().getName() + "\t come in");
try {
//線程暫停3s
TimeUnit.SECONDS.sleep(3);
myData.addToSixty();
System.out.println(Thread.currentThread().getName() + "\t update value:" + myData.num);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}, "thread1").start();
//第二個線程是main線程
while (myData.num == 0) {
//如果myData的num一直為零，main線程一直在這里循環
}
System.out.println(Thread.currentThread().getName() + "\t mission is over, num value is " + myData.num);
}
}
class MyData {
// int num = 0;
volatile int num = 0;
public void addToSixty() {
this.num = 60;
}
}
輸出結果：
thread1 come in
thread1 update value:60
// 線程沒有檢測到值的變化進入死循環
當我們加上volatile關鍵字后，volatile int num = 0;輸出結果為：
thread1 come in
thread1 update value:60
main mission is over, num value is 60
//程序沒有死循環，結束執行
2.2 原子性：
一個線程在操作某個對象時，對象的值發生更改，并更新回主內存，其余線程還未獲得更新的消息，將值同樣更新回主內存，造成數據丟失的情況，即不保證原子性
class MyData {
/**
* 增強了各線程的可見性
*/
volatile int number = 0;
public void addTo60() {
this.number = 60;
}
/**
* 請注意，此時 number 前面是加了volatile關鍵字修飾的，volatile不保證原子性
*/
public void addPlusPlus() {
// number++ 在多線程下是非線程安全的，如何不加synchronized解決？
number++;
}
AtomicInteger atomicInteger = new AtomicInteger();
public void addMyAtomic() {
atomicInteger.getAndIncrement();
}
}
/**
* 1、驗證 volatile 的可見性
* 1.1 加入 int number =0 ，number變量之前根本沒有添加 volatile 關鍵字修飾
* 1.2 添加了volatile ，可以解決可見性問題
* <p>
* 2、驗證volatile不保證原子性
* 2.1 原子性指的是什么意思：
* 不可分割，完整性，也即某個線程正在做某個具體業務時，中間不可以被加塞或者被分割。需要整體完整
* 要么同時成功，要么同時失敗。
* 2.2 volatile 不保證原子性的演示案例
* 2.3 why
* 2.4 如何解決原子性
* * 加 synchronized
* * 使用我們 JUC 下的AtomicInteger
*/
public class VolatileDemo {
public static void main(String[] args) {
MyData myData = new MyData();
for (int i = 0; i < 20; i++) {
new Thread(() -> {
for (int j = 0; j < 1000; j++) {
myData.addPlusPlus();
myData.addMyAtomic();
}
}, String.valueOf(i)).start();
}
// 需要等待上賣弄20個線程都全部計算完成后，在用main線程去得最終的結果值，看是多少？
while (Thread.activeCount() > 2) {
// 禮讓線程
Thread.yield();
}
Map<String, String> s = new HashMap<>();
System.out.println(Thread.currentThread().getName() + "\t int type, finally number value : " + myData.number);
System.out.println(Thread.currentThread().getName() + "\t atomicInteger, finally number value : " + myData.atomicInteger);
}
執行結果
main int type, finally number value : 15940
main atomicInteger, finally number value : 20000
2.3 禁止指令重排
計算機執行程序時，為了提高性能，編譯器和處理器常常會對 指令做重排,一般分以下三種
源代碼 ==》編譯器優化的重排 ==》指令并行的重排 ==》 內存系統的重排 ==》最終執行的指令
單線程環境里面確保程序最終執行和代碼順序執行的結果一致
處理器在進行重排序時，必須要考慮指令之間的
數據依賴性多線程環境中線程交替執行，由于編譯器優化重排的存在，兩個線程中使用的變量能否保證一致性是無法確定的，結果無法預測
了解一個概念，內存屏障（Memory Barrier）又稱內存柵欄，是一個CPU指令，他的作用有兩個：
- 一是保證特定操作的執行順序
- 而是保證某些變量的內存可見性（利用該特性，實現volatile的內存可見性）
由于編譯器和處理器都能執行指令重排優化，如果在指令間插入一條Memory Barrier，則會告訴編譯器和CPU，不管什么指令都不能和這條Memory Barrier 指令重排序，也就是說
通過插入內存屏障，禁止在內存屏障前后的指令執行重排序優化。內存屏障另外一個作用是強制刷出各種CPU的緩存數據，因此任何CPU上的線程都能讀取到這些數據的最新版本。
3、volatile 在單例模式下的應用
3.1 普通單例模式在多線程下的結果
public class SingletonDemo {
private static SingletonDemo instance = null;
private SingletonDemo() {
System.out.println(Thread.currentThread().getName() + "\t 構造方法SingletonDemo（）");
}
public static SingletonDemo getInstance() {
if (instance == null) {
instance = new SingletonDemo();
}
return instance;
}
public static void main(String[] args) {
//構造方法只會被執行一次
// System.out.println(getInstance() == getInstance());
// System.out.println(getInstance() == getInstance());
// System.out.println(getInstance() == getInstance());
//并發多線程后，構造方法會在一些情況下執行多次
for (int i = 0; i < 10; i++) {
new Thread(() -> {
SingletonDemo.getInstance();
}, "Thread " + i).start();
}
}
}
3.2 解決方法
-
加入單例模式 DCL（Double Check Lock雙端檢鎖機制） 代碼
DCL （Double Check Lock雙端檢鎖機制）在加鎖前和加鎖后都進行一次判斷public static SingletonDemo getInstance() { if (instance == null) { synchronized (SingletonDemo.class) { if (instance == null) { instance = new SingletonDemo(); } } } return instance; }大部分運行結果構造方法只會被執行一次，但指令重排機制會讓程序很小的幾率出現構造方法被執行多次，DCL（雙端檢鎖）機制不一定線程安全，原因時有指令重排的存在，加入volatile可以禁止指令重排
原因是在某一個線程執行到第一次檢測，讀取到instance不為null時，instance的引用對象可能
沒有完成初始化。instance=new SingleDemo();可以被分為一下三步（偽代碼）：memory = allocate();//1.分配對象內存空間 instance(memory); //2.初始化對象 instance = memory; //3.設置instance執行剛分配的內存地址，此時instance!=null步驟2和步驟3不存在數據依賴關系，而且無論重排前還是重排后程序的執行結果在單線程中并沒有改變，因此這種重排優化時允許的，如果3步驟提前于步驟2，但是instance還沒有初始化完成，指令重排只會保證串行語義的執行的一致性（單線程），但并不關心多線程間的語義一致性。所以當一條線程訪問instance不為null時，由于instance示例未必已初始化完成，也就造成了線程安全問題。
-
加上 volatile 禁止指令重排
private static volatile SingletonDemo instance = null;
