什么是volatile關(guān)鍵字

volatile是Java中用于修飾變量的關(guān)鍵字，其可以保證該變量的可見性以及順序性，但是無法保證原子性。更準(zhǔn)確地說是volatile關(guān)鍵字只能保證單操作的原子性， 比如x=1 ，但是無法保證復(fù)合操作的原子性，比如x++

其為Java提供了一種輕量級的同步機(jī)制：保證被volatile修飾的共享變量對所有線程總是可見的，也就是當(dāng)一個線程修改了一個被volatile修飾共享變量的值，新值總是可以被其他線程立即得知。相比于synchronized關(guān)鍵字（synchronized通常稱為重量級鎖），volatile更輕量級，開銷低，因?yàn)樗粫鹁€程上下文的切換和調(diào)度。

保證可見性

可見性：是指當(dāng)多個線程訪問同一個變量時，一個線程修改了這個變量的值，其他線程能夠立即看到修改的值。我們一起來看一個例子：

public class VisibilityTest {
    private boolean flag = true;
?
    public void change() {
        flag = false;
        System.out.println(Thread.currentThread().getName() + "，已修改flag=false");
    }
?
    public void load() {
        System.out.println(Thread.currentThread().getName() + "，開始執(zhí)行.....");
        int i = 0;
        while (flag) {
            i++;
        }
        System.out.println(Thread.currentThread().getName() + ",結(jié)束循環(huán)");
    }
?
    public static void main(String[] args) throws InterruptedException {
        VisibilityTest test = new VisibilityTest();
?
        // 線程threadA模擬數(shù)據(jù)加載場景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();
?
        // 讓threadA執(zhí)行一會兒
        Thread.sleep(1000);
        // 線程threadB 修改 共享變量flag
        Thread threadB = new Thread(() -> test.change(), "threadB");
        threadB.start();
?
    }
}

其中：threadA 負(fù)責(zé)循環(huán)，threadB負(fù)責(zé)修改 共享變量flag，如果flag=false時，threadA 會結(jié)束循環(huán)，但是上面的例子會死循環(huán)！ 原因是threadA無法立即讀取到共享變量flag修改后的值。 我們只需private volatile boolean flag = true;，加上volatile關(guān)鍵字threadA就可以立即退出循環(huán)了。

其中Java中的volatile關(guān)鍵字提供了一個功能：那就是被volatile修飾的變量P被修改后，JMM會把該線程本地內(nèi)存中的這個變量P，立即強(qiáng)制刷新到主內(nèi)存中去，導(dǎo)致其他線程中的volatile變量P緩存無效，也就是說其他線程使用volatile變量P在時，都是從主內(nèi)存刷新的最新數(shù)據(jù)。而普通變量的值在線程間傳遞的時候一般是通過主內(nèi)存以共享內(nèi)存的方式實(shí)現(xiàn)的；

因此，可以使用volatile來保證多線程操作時變量的可見性。除了volatile，Java中的synchronized和final兩個關(guān)鍵字 以及各種Lock也可以實(shí)現(xiàn)可見性。加鎖的話， 當(dāng)一個線程進(jìn)入 synchronized代碼塊后，線程獲取到鎖，會清空本地內(nèi)存，然后從主內(nèi)存中拷貝共享變量的最新值到本地內(nèi)存作為副本，執(zhí)行代碼，又將修改后的副本值刷新到主內(nèi)存中，最后線程釋放鎖。

保證有序性

有序性，顧名思義即程序執(zhí)行的順序按照代碼的先后順序執(zhí)行。但現(xiàn)代的計(jì)算機(jī)中CPU中為了能夠讓指令的執(zhí)行盡可能地同時運(yùn)行起來，提示計(jì)算機(jī)性能，采用了指令流水線。一個 CPU 指令的執(zhí)行過程可以分成 4 個階段：取指、譯碼、執(zhí)行、寫回。這 4 個階段分別由 4 個獨(dú)立物理執(zhí)行單元來完成。

理想的情況是：指令之間無依賴，可以使流水線的并行度最大化 但是如果兩條指令的前后存在依賴關(guān)系，比如數(shù)據(jù)依賴，控制依賴等，此時后一條語句就必需等到前一條指令完成后，才能開始。所以CPU為了提高流水線的運(yùn)行效率，對無依賴的前后指令做適當(dāng)?shù)膩y序和調(diào)度，即現(xiàn)代的計(jì)算機(jī)中CPU是亂序執(zhí)行指令的

另一方面，只要不會改變程序的運(yùn)行結(jié)果，Java編譯器是可以通過指令重排來優(yōu)化性能。然而，重排可能會影響本地處理器緩存與主內(nèi)存交互的方式，可能導(dǎo)致在多線程的情況下發(fā)生"細(xì)微"的BUG。

指令重排一般可以分為如下三種類型：

• 編譯器優(yōu)化重排序，編譯器在不改變單線程程序語義的前提下，可以重新安排語句的執(zhí)行順序。
• 指令級并行重排序，現(xiàn)代處理器采用了指令級并行技術(shù)來將多條指令重疊執(zhí)行。如果不存在數(shù)據(jù)依賴性，處理器可以改變語句對應(yīng)機(jī)器指令的執(zhí)行順序。
• 內(nèi)存系統(tǒng)重排序，由于處理器使用緩存和讀 / 寫緩沖區(qū)，這使得加載和存儲操作看上去可能是在亂序執(zhí)行。這并不是顯式的將指令進(jìn)行重排序，只是因?yàn)榫彺娴脑?，讓指令的?zhí)行看起來像亂序。

從 Java 源代碼到最終執(zhí)行的指令序列，一般會經(jīng)歷下面三種重排序：

編譯器優(yōu)化重排序 - 指令級并行重排序 - 內(nèi)存系統(tǒng)重排序 - 最終執(zhí)行的指令排序

變量初始化賦值

我們一起來看一個例子，讓大家體悟volatile關(guān)鍵字的禁止指令重排的作用：

int i = 0;
int j = 0;
int k = 0;
i = 10; 
j = 1; 

對于上面的代碼我們正常的執(zhí)行流程是：

• 初始化i
• 初始化j
• 初始化k
• i賦值
• j賦值

但由于指令重排序問題，代碼的執(zhí)行順序未必就是編寫代碼時候的順序。語句可能的執(zhí)行順序如下：

• 初始化i
• i賦值
• 初始化j
• j賦值
• 初始化k

指令重排對于非原子性的操作，在不影響最終結(jié)果的情況下，其拆分成的原子操作可能會被重新排列執(zhí)行順序,提升性能。指令重排不會影響單線程的執(zhí)行結(jié)果，但是會影響多線程并發(fā)執(zhí)行的結(jié)果正確性。

但當(dāng)我們用volatile修飾變量k時：

int i = 0;
int j = 0;
volatile int k = 0;
i = 10; 
j = 1; 

這樣會保證上面代碼執(zhí)行順序：變量i和j的初始化，在volatile int k = 0之前，變量i和j的賦值操作在volatile int k = 0后面

懶漢式單例 -- 雙重校驗(yàn)鎖 volatile版

我們可以使用volatile關(guān)鍵字去阻止重排 volatile變量周圍的讀寫指令，這種操作通常稱為 memory barrier （內(nèi)存屏障）

隱藏特性

volatile關(guān)鍵字除了禁止指令重排的作用，還有一個特性： 當(dāng)線程向一個volatile 變量寫入時，在線程寫入之前的其他所有變量（包括非volatile變量）也會刷新到主內(nèi)存。當(dāng)線程讀取一個 volatile變量時，它也會讀取其他所有變量（包括非volatile變量）與volatile變量一起刷新到主內(nèi)存。 盡管這是一個重要的特性，但是我們不應(yīng)該過于依賴這個特性，來"自動"使周圍的變量變得volatile，若是我們想讓一個變量是volatile的，我們編寫程序的時候需要非常明確地用volatile關(guān)鍵字來修飾。

無法保證原子性

volatile關(guān)鍵字無法保證原子性 ，更準(zhǔn)確地說是volatile關(guān)鍵字只能保證單操作的原子性， 比如x=1 ，但是無法保證復(fù)合操作的原子性，比如x++

所謂原子性：即一個或者多個操作作為一個整體，要么全部執(zhí)行，要么都不執(zhí)行，并且操作在執(zhí)行過程中不會被線程調(diào)度機(jī)制打斷；而且這種操作一旦開始，就一直運(yùn)行到結(jié)束，中間不會有任何上下文切換（context switch）

int  = 0;   //語句1，單操作,原子性的操作
?
i++;         //語句2，復(fù)合操作，非原子性的操作

其中：語句2i++ 其實(shí)在Java中執(zhí)行過程，可以分為3步：

• i 被從局部變量表（內(nèi)存）取出，
• 壓入操作棧（寄存器），操作棧中自增
• 使用棧頂值更新局部變量表（寄存器更新寫入內(nèi)存）

執(zhí)行上述3個步驟的時候是可以進(jìn)行線程切換的，或者說是可以被另其他線程的 這3 步打斷的，因此語句2不是一個原子性操作

volatile版

我們再來看一個例子：

public class Test1 {
?
    public static volatile int val;
?
    public static void add() {
        for (int i = 0; i < 1000; i++) {
            val++;
        }
    }
?
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(Test1::add);
        Thread t2 = new Thread(Test1::add);
        t1.start();
        t2.start();
        t1.join();//等待該線程終止
        t2.join();
        System.out.println(val);
    }
}

2個線程各循環(huán)2000次，每次+1，如果volatile關(guān)鍵字能夠保證原子性，預(yù)期的結(jié)果是2000，但實(shí)際結(jié)果卻是：1127，而且多次執(zhí)行的結(jié)果都不一樣，可以發(fā)現(xiàn)volatile關(guān)鍵字無法保證原子性。

synchronized版

我們可以利用synchronized關(guān)鍵字來解決上面的問題：

public class SynchronizedTest {
    public static int val;
?
    public synchronized static void add() {
        for (int i = 0; i < 1000; i++) {
            val++;
        }
    }
?
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(SynchronizedTest::add);
        Thread t2 = new Thread(SynchronizedTest::add);
        t1.start();
        t2.start();
        t1.join();//等待該線程終止
        t2.join();
        System.out.println(val);
    }
}

運(yùn)行結(jié)果：2000

Lock版

我們還可以通過加鎖來解決上述問題：

public class LockTest {
?
    public static int val;
?
    static Lock lock = new ReentrantLock();
?
    public static void add() {
?
        for (int i = 0; i < 1000; i++) {
?
            lock.lock();//上鎖
            try {
                val++;
            }catch(Exception e) {
                e.printStackTrace();
            }finally {
                lock.unlock();//解鎖
            }
?
        }
?
    }
?
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(LockTest::add);
        Thread t2 = new Thread(LockTest::add);
        t1.start();
        t2.start();
        t1.join();//等待該線程終止
        t2.join();
        System.out.println(val);
    }
?
}

運(yùn)行結(jié)果：2000

Atomic版 i++

Java從JDK 1.5開始提供了java.util.concurrent.atomic包（以下簡稱Atomic包），這個包中的原子操作類, 靠CAS循環(huán)的方式來保證其原子性，是一種用法簡單、性能高效、線程安全地更新一個變量的方式。

這些類可以保證多線程環(huán)境下，當(dāng)某個線程在執(zhí)行atomic的方法時，不會被其他線程打斷，而別的線程就像自旋鎖一樣，一直等到該方法執(zhí)行完成，才由JVM從等待隊(duì)列中選擇一個線程執(zhí)行。

我們來用atomic包來解決volatile原子性的問題：

public class AtomicTest {
    public static AtomicInteger val = new AtomicInteger();
?
    public static void add() {
        for (int i = 0; i < 1000; i++) {
            val.getAndIncrement();
        }
    }
?
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(AtomicTest::add);
        Thread t2 = new Thread(AtomicTest::add);
        t1.start();
        t2.start();
        t1.join();//等待該線程終止
        t2.join();
        System.out.println(val);
    }
}

運(yùn)行結(jié)果：2000, 如果我們維護(hù)現(xiàn)有的項(xiàng)目，如果遇到volatile變量最好將其替換為Atomic 變量,除非你真的特別了解volatile。Atomic 就不展開說了，先挖個坑，以后補(bǔ)上

volatile 原理

當(dāng)大家仔細(xì)讀完上文的懶漢式單例 -- 雙重校驗(yàn)鎖 volatile版，會發(fā)現(xiàn)volatile關(guān)鍵字修飾變量后，我們反匯編后會發(fā)現(xiàn) 多出了lock前綴指令，lock前綴指令在匯編中 LOCK指令前綴功能如下：

• 被修飾的匯編指令成為"原子的"
• 與被修飾的匯編指令一起提供"內(nèi)存屏障"效果（lock指令可不是內(nèi)存屏障）

內(nèi)存屏障主要分類：

• 一類是可以強(qiáng)制讀取主內(nèi)存，強(qiáng)制刷新主內(nèi)存的內(nèi)存屏障，叫做Load屏障和Store屏障
• 另一類是禁止指令重排序的內(nèi)存屏障，主要有四個分別叫做LoadLoad屏障、StoreStore屏障、LoadStore屏障、StoreLoad屏障

這4個屏障具體作用：

• LoadLoad屏障：（指令Load1; LoadLoad; Load2），在Load2及后續(xù)讀取操作要讀取的數(shù)據(jù)被訪問前，保證Load1要讀取的數(shù)據(jù)被讀取完畢。
• LoadStore屏障：（指令Load1; LoadStore; Store2），在Store2及后續(xù)寫入操作被刷出前，保證Load1要讀取的數(shù)據(jù)被讀取完畢。
• StoreStore屏障：（指令Store1; StoreStore; Store2），在Store2及后續(xù)寫入操作執(zhí)行前，保證Store1的寫入操作對其它處理器可見。
• StoreLoad屏障：（指令Store1; StoreLoad; Load2），在Load2及后續(xù)所有讀取操作執(zhí)行前，保證Store1的寫入對所有處理器可見。它的開銷是四種屏障中最大的。在大多數(shù)處理器的實(shí)現(xiàn)中，這個屏障是個萬能屏障，兼具其它三種內(nèi)存屏障的功能

對于volatile操作而言，其操作步驟如下：

• 每個volatile寫入之前，插入一個 StoreStore，寫入以后插入一個 StoreLoad
• 每個volatile讀取之前，插入一個 LoadLoad，讀取之后插入一個 LoadStore

我們再總結(jié)以下，用volatile關(guān)鍵字修飾變量后，主要發(fā)生的變化有哪些？：

• 當(dāng)一個線程修改了 volatile 修飾的變量，當(dāng)修改后的變量寫回主內(nèi)存時，其他線程能立即看到最新值。即volatile關(guān)鍵字保證了并發(fā)的可見性

• 使用volatile關(guān)鍵字修飾共享變量后，每個線程要操作該變量時會從主內(nèi)存中將變量拷貝到本地內(nèi)存作為副本，但當(dāng)線程操作完變量副本，會強(qiáng)制將修改的值立即寫入主內(nèi)存中。
• 然后通過 CPU總線嗅探機(jī)制告知其他線程中該變量副本全部失效，（在CPU層，一個處理器的緩存回寫到內(nèi)存會導(dǎo)致其他處理器的緩存行無效），若其他線程需要該變量，必須重新從主內(nèi)存中讀取。

• 在x86的架構(gòu)中，volatile關(guān)鍵字 底層 含有l(wèi)ock前綴的指令，與被修飾的匯編指令一起提供"內(nèi)存屏障"效果，禁止了指令重排序，保證了并發(fā)的有序性

確保一些特定操作執(zhí)行的順序,讓cpu必須按照順序執(zhí)行指令，即當(dāng)指令重排序時不會把其后面的指令排到內(nèi)存屏障之前的位置，也不會把前面的指令排到內(nèi)存屏障的后面；即在執(zhí)行到內(nèi)存屏障這句指令時，在它前面的操作已經(jīng)全部完成；

• volatile關(guān)鍵字無法保證原子性 ，更準(zhǔn)確地說是volatile關(guān)鍵字只能保證單操作的原子性， 比如x=1 ，但是無法保證復(fù)合操作的原子性，比如x++。

有人可能問賦值操作是原子操作，本來就是原子性的，用volatile修飾有什么意義？ 在Java 數(shù)據(jù)類型足夠大的情況下（在 Java 中 long 和 double 類型都是 64 位），寫入變量的過程分兩步進(jìn)行，就會發(fā)生 Word tearing （字分裂） 情況。 JVM 被允許將64位數(shù)量的讀寫作為兩個單獨(dú)的32位操作執(zhí)行，這增加了在讀寫過程中發(fā)生上下文切換的可能性，多線程的情況下可能會出現(xiàn)值會被破壞的情況

在缺乏任何其他保護(hù)的情況下，用 volatile 修飾符定義一個 long 或 double 變量，可阻止字分裂情況

參考資料：

《On Java 8》

《Java并發(fā)編程》

《深入理解JVM虛擬機(jī)》

總結(jié)

到此這篇關(guān)于Java中不可或缺的關(guān)鍵字volatile的文章就介紹到這了,更多相關(guān)Java關(guān)鍵字volatile內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！