java volatile 關鍵字詳解

一,什么是volatile關鍵字,作用是什么

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

? 作用是: 1.保證可見性 2.禁止指令重排 3.不保證原子性

本篇具體就講解 什么叫保證了可見性, 什么叫禁止指令重排,什么是原子性

而在這之前需要對JMM 有所了解

二,什么是JMM

? JMM(java 記憶體模型 Java Memory Model 簡稱JMM) 本身是一個抽象的概念,并不在記憶體中真實存在的,它描述的是一組規范或者規則,通過這組規范定義了程式中各個變數(實體欄位,靜態欄位和構成陣列物件的元素)的訪問方式.

JMM的同步規定:

? 1.執行緒解鎖之前,必須把共享變數重繪回主存

? 2.執行緒加鎖鎖之前,必須讀取主存的最新值到自己的作業空間

? 3.加鎖解鎖必須是 同一把鎖

?

? 由于 JMM運行程式的物體是執行緒.而每個執行緒創建時JMM都會為其創建一個自己的作業記憶體(堆疊空間),作業記憶體是每個執行緒的私有 資料區域.而java記憶體模型中規定所有的變數都存盤在主記憶體中,主記憶體是共享記憶體區域,所有執行緒都可以訪問,但執行緒的變數的操作(讀取賦值等)必須在自己的作業記憶體中去進行,首先要 將變數從主存拷貝到自己的作業記憶體中,然后對變數進行操作,操作完成后再將變數操作完后的新值寫回主記憶體,不能直接操作主記憶體的變數,各個執行緒的作業記憶體中存盤著主記憶體的變數拷貝的副本,因IC不同的執行緒間無法訪問對方的作業記憶體,執行緒間的通信必須在主記憶體來完成, 其簡要訪問程序如下圖:

三,可見性

? 可見性:指當多個執行緒訪問同一個變數時，一個執行緒修改了這個變數的值，其他執行緒能夠立即看得到修改的值，

? 通過前面的 JMM介紹,我們知道各個執行緒對主記憶體的變數的操作都是各個執行緒各自拷貝到自己的作業記憶體中進行操作,然后在寫回主記憶體中

? 這就可能存在一個執行緒a修改了共享變數X的值但還未寫回主記憶體,又有一個執行緒b對共享變數X進行操作,但 此時執行緒a的作業記憶體的共享變數X對執行緒吧來說是不可見的,這種作業記憶體與主記憶體同步延遲的問題就造成了可見性問題

四,不保證原子性

? 原子性:某個執行緒在執行某項業務時，中間不可被加塞或分割，需要整體完整，要么同時成功，要么同時失敗

?

    class MyData{
?    volatile int number = 0;
?    Object object = new Object();

    public void addTo60(){
        this.number = 60;
    }
    
    public void addPlusPlus(){
        this.number++;
    }
    
    AtomicInteger atomicInteger = new AtomicInteger();
    
    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }
}

/**
 * 驗證volatile的可見性

 * 1.當number未被volatile修飾時，new Thread將number值改為60，但main執行緒并不知道，會一直在回圈中出不來

 * 2.當number使用volatile修飾，new Thread改變number值后，會通知main執行緒主記憶體的值已被修改，結束任務，體現了可見性
 *

 * 驗證volatile不保證原子性

 * 1.原子性是指，某個執行緒在執行某項業務時，中間不可被加塞或分割，需要整體完整，要么同時成功，要么同時失敗
 *

 * 如何解決呢？

 * 1.使用synchronize

 * 2.使用AtomicInteger
 *
 */
public class VolatileDemo {
    public static void main(String[] args) {
        //seeByVolatile();
        atomic();
    }
    //驗證原子性
    public static void atomic() {
        MyData myData = new MyData();
        for (int i = 1; i <= 20; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 1; j <= 1000; j++) {
                        /*synchronized (myData.object){
                            myData.addPlusPlus();
                        }*/
                        myData.addPlusPlus();
                        myData.addAtomic();
                    }
                }
            }).start();
        }

        //等待上面20個執行緒全部計算結束
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        
        System.out.println(Thread.currentThread().getName() + "int finally number is " + myData.number);
        System.out.println(Thread.currentThread().getName() + "AtomicInteger finally number is " + myData.atomicInteger);
    }

    //驗證可見性的方法
    public static void seeByVolatile() {
        MyData myData = new MyData();
        //第一個執行緒
        new Thread(){
            public void run(){
                System.out.println(Thread.currentThread().getName() + " come in");
                try {
                    sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                myData.addTo60();
                System.out.println(Thread.currentThread().getName() + " update number to " + myData.number);
            }
        }.start();

        //第二個執行緒 main
        while (myData.number == 0){
        
        }
        System.out.println(Thread.currentThread().getName() + "mission is over");
    }
}

number++在多執行緒下是非執行緒安全,不是原子性操作？

五,禁止指令重排

? 計算機在執行程式時,為了提高性能,編譯器和處理 器常常會對指令做重排,一般分為一下三種:

單執行緒的環境里指令重排確保最終執行的結果和代碼順序執行的結果一致

處理器在進行指令重排是必須 要考慮指令之間的資料依賴性

多執行緒的環境交替執行,由于編譯器優化重排的存在,倆個執行緒使用變數能否保證一致性是無法確定的,無法預料的

實體一:

實體二:

執行緒操作資源類，執行緒1訪問method1，執行緒2訪問method2，正常情況順序執行，a=6
多執行緒下假設出現了指令重排，陳述句2在陳述句1之前，當執行完flag=true后，另一個執行緒馬上執行method2，a=5

所以volatile 禁止指令重排,從而避免多執行緒的 環境下出現執行亂序 的情況

六:使用volatile 的經典案例

 單例DCL的代碼

public class SingletonDemo {
    private static SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "構造方法");
    }
    
    //DCL雙端加鎖機制
    public static SingletonDemo getInstance(){
        if (instance == null){
            synchronized (SingletonDemo.class){
                if (instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

這種寫法在多執行緒條件下可能正確率為99.999999%，但可能由于指令重排出錯

原因在于某一個執行緒執行到第一次檢測,讀取到instance不為null,instance參考物件可能還沒有完成初始化.

instance = new SingletonDemo();; 分為一下三步

1. memory = allocate() //分配記憶體
2. ctorInstanc(memory) //初始化物件
3. instance = memory //設定instance指向剛分配的地址

2 ,3 步不存在資料依賴, 可以指令重排的執行順序為 1 ,3 ,2,設定instance指向剛分配的地址,次數instance還沒有初始化完

但此時instance不為null了,若正好此時有一個執行緒來訪問,就出現了執行緒安全問題

所以需要添加volatile 關鍵字

public class SingletonDemo {
    private static volatile SingletonDemo instance = null;

    private SingletonDemo(){
        System.out.println(Thread.currentThread().getName() + "構造方法");
    }
    //DCL雙端加鎖機制
    public static SingletonDemo getInstance(){
        if (instance == null){
            synchronized (SingletonDemo.class){
                if (instance == null){
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }
}