目錄

一、volatile出現(xiàn)背景

二、JMM概述

2.1、JMM的規(guī)定

?三、volatile的特性

3.1、可見性

?3.1.1、舉例說明

?3.1.2、總結(jié)

3.2、無法保證原子性

3.2.1、舉例說明

3.2.2、分析

3.2.3、使用volatile對原子性測試

?3.2.4、使用鎖機(jī)制

?3.2.5、總結(jié)

3.3、禁止指令重排序

?四、volatile的內(nèi)存語義

4.1、volatile 與 static

五、總結(jié)

一、volatile出現(xiàn)背景

????????我們在寫項目的時候，有時會使用多線程。為了保證一部分線程之間的通信，所以需要線程中的一些變量具有可見性。

說到線程可見性，對于Java而言，有兩種方法實(shí)現(xiàn)：volatile和synchronized。

需要注意的是：volatile只用來保證該變量對所有線程的可見性，但不保證原子性。

????????雖然加鎖同樣能解決共享變量不可見性的問題，但是加鎖和鎖的釋放過程都是會有性能消耗的，所以在解決共享變量不可見性的問題時，我們首選 volatile關(guān)鍵字。

二、JMM概述

????????JMM就是Java內(nèi)存模型(Java Memory Model)，是Java虛擬機(jī)規(guī)范的一種內(nèi)存模型，屏蔽掉各種硬件和操作系統(tǒng)的內(nèi)存訪問差異，以實(shí)現(xiàn)讓Java程序在各種平臺下都能達(dá)到一致的并發(fā)效果。

????????Java內(nèi)存模型規(guī)定了Java程序的變量（包括實(shí)例變量，靜態(tài)變量，但是不包括局部變量和方法參數(shù)）全部存儲在主內(nèi)存中，定義了各種變量（線程的共享變量）的訪問規(guī)則，以及在JVM中將變量存儲到主內(nèi)存與從主內(nèi)存讀取變量的底層細(xì)節(jié)。

2.1、JMM的規(guī)定

• 所有共享變量都存在于主內(nèi)存（包括實(shí)例變量，靜態(tài)變量，但是不包括局部變量和方法參數(shù)），因為局部變量是線程私有，不存在競爭問題。
• 每個線程都有自己的工作內(nèi)存，所需要的變量是主內(nèi)存中的副本。
• 線程對變量的讀、寫操作都只能在工作內(nèi)存中完成，不能直接參與讀寫主內(nèi)存的變量。
• 不同的線程也不能去直接訪問不同線程的工作內(nèi)存的變量，線程間的變量傳遞需要通過主內(nèi)存來中轉(zhuǎn)完成。

?三、volatile的特性

3.1、可見性

????????volatile可以保證線程的可見性，即當(dāng)多個線程訪問同一個變量的時候，此變量發(fā)生改變，其他線程也能實(shí)時獲得到這個修改的值。

????????在java中，變量都會被放在堆內(nèi)存(所有線程共享的內(nèi)存)中，多個線程對共享內(nèi)存是不可見的，當(dāng)每個線程去獲取這個變量的值時，實(shí)際上是copy一份副本在線程自身的工作內(nèi)存中。

?3.1.1、舉例說明

????????我們將main作為主線程，MyThread為子線程。在子線程中定義一個共享變量flag，主線程會去訪問這個共享變量。在不加volatile的時候，flag在主線程讀到的永遠(yuǎn)是為false，因為兩個線程是不可見的。

public class Test {
    public static void main(String[] args) { // 主線程
        MyThread my = new MyThread();
        my.start();
        while (true) {
            if (my.isFlag()) System.out.println("進(jìn)入等待...");
        }
    }
}

class MyThread extends Thread { // 子線程
    private volatile boolean flag = false;
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        flag = true;
        System.out.println("flag 修改完畢！");
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

????????實(shí)際上是已經(jīng)修改了的，只是線程讀的都是自己的工作內(nèi)存中的數(shù)據(jù)，然而，要解決這個問題，可以使用synchronized加鎖和volatile修飾共享變量來解決，這兩種都能讓主線程拿到子線程修改的變量的值。

synchronized (my) {
    if (my.isFlag()) System.out.println("進(jìn)入等待...");
}

????????加了synchronized鎖，首先該線程會獲得鎖對象，接著會去清空工作內(nèi)存，再從主內(nèi)存中copy一份最新的值到工作變量中，接著執(zhí)行代碼， 打印輸出，最后釋放鎖。

?

????????當(dāng)然還能使用volatile關(guān)鍵字去修飾共享變量。一開始子線程從主內(nèi)存中獲取變量的副本到自己的工作內(nèi)存，進(jìn)行改值，此時還未寫回主內(nèi)存，主線程從主內(nèi)存獲取的變量的值也是一開始的初始值，等到子線程寫回到主內(nèi)存時，接下來其他線程的工作內(nèi)存中此變量的副本將會失效，也就是類似于監(jiān)聽。在需要對此變量進(jìn)行操作的時候，將會到主內(nèi)存獲取新的值保存到線程自身的工作內(nèi)存中，從而確保了數(shù)據(jù)的一致。

?3.1.2、總結(jié)

????????volatile能夠保證不同線程對共享變量的可見性，也就是修改過的volatile修飾的共享變量只要被寫回到主內(nèi)存中，其他線程就能夠馬上看到最新的數(shù)據(jù)。

????????當(dāng)一個線程對volatile修飾的變量進(jìn)行寫的操作時候，JMM會立即把該線程自身的工作內(nèi)存的共享變量刷新到主內(nèi)存中。

????????當(dāng)對線程進(jìn)行讀操作的時候，JMM會立即把當(dāng)前線程自身的工作內(nèi)存設(shè)置無效，從而從主內(nèi)存中去獲取共享變量的數(shù)據(jù)。

3.2、無法保證原子性

原子性指的是一項操作要么都執(zhí)行，要么都不執(zhí)行，中途不允許中斷也不受其他線程干擾。

3.2.1、舉例說明

????????我們看以下案例代碼，簡單描述一下，AutoAccretion是一個線程類，里面定義了一個共享變量count，并去執(zhí)行1萬次的自增，在main線程中調(diào)用多線程去執(zhí)行自增。我們所期望的結(jié)果是最終count的值是1000000，因為每個線程自增1萬次，一共100個線程。

public class Test{
    public static void main(String[] args) {
        Runnable thread = new AutoAccretion();
        for (int i = 1; i <= 100; i++) {
            new Thread(thread, "線程" + i).start();
        }
    }
}

class AutoAccretion implements Runnable {
    private int count = 0;
    @Override
    public void run() {
        for (int i = 1; i <= 10000; i++) {
            count++;
            System.out.println(Thread.currentThread().getName() + "count ==> " + count);
        }
    }
}

3.2.2、分析

????????count++操作首先會從主內(nèi)存中拷貝變量副本到工作內(nèi)存中，在工作內(nèi)存中進(jìn)行自增操作，最后將工作內(nèi)存的數(shù)據(jù)寫回主內(nèi)存中。運(yùn)行之后會發(fā)現(xiàn)，count的值是沒辦法到達(dá)1百萬的。主要原因是count++自增操作并不是原子性的，也就是說在進(jìn)行count++的時候可能被其他線程打斷。

????????當(dāng)線程1拿到count=0，進(jìn)行自增后count=1，但是還沒寫到主內(nèi)存，線程2獲取的數(shù)據(jù)可能也是count=0，經(jīng)過自增count=1，兩者在寫回內(nèi)存，就會導(dǎo)致數(shù)據(jù)的錯誤。

3.2.3、使用volatile對原子性測試

現(xiàn)在通過volatile去修飾共享變量，運(yùn)行之后，發(fā)現(xiàn)依然沒辦法達(dá)到一百萬。

?3.2.4、使用鎖機(jī)制

????????通過使用synchronized鎖對代碼快進(jìn)行加鎖，從而確保原子性，確保某個線程對count進(jìn)行操作不受其他線程的干擾。

class AutoAccretion implements Runnable {
    private volatile int count = 0; // 并發(fā)下可見性
    @Override
    public void run() {
        synchronized (this) {
            for (int i = 1; i <= 10000; i++) {
                count++;
                System.out.println(Thread.currentThread().getName() + "count ==> " + count);
            }
        }
    }
}

通過驗證可以知道能夠?qū)崿F(xiàn)原子性。

?3.2.5、總結(jié)

????????在多線程下，volatile關(guān)鍵字可以保證共享變量的可見性，但是不能保證對變量操作的原子性，因此，在多線程下即使加了volatile修飾的變量也是線程不安全的。要保證原子性就得通過加鎖的機(jī)制。

????????除了這個方法，Java還能用過原子類（java.util.concurrent.atomic包） 來保證原子性。

3.3、禁止指令重排序

1、什么是指令重排序

指令重排序：為了提高程序性能，編譯器和處理器會對代碼指令的執(zhí)行順序進(jìn)行重排序。

良好的內(nèi)存模型實(shí)際上會通過軟件和硬件一同盡可能提高執(zhí)行效率。JMM對底層約束盡量減少，在執(zhí)行程序時，為了提高性能，編譯器和處理器會對指令進(jìn)行重排序。

一般重排序有以下三種：

• 編譯器優(yōu)化的重排序：編譯器在不改變單線程程序語義可以對執(zhí)行順序進(jìn)行排序。
• 指令集并行的重排序：如果指令不存在相互依賴，那么指令可以改變執(zhí)行的順序，從而能夠減少load/store操作。
• 內(nèi)存系統(tǒng)的重排序：處理器使用緩存和讀/寫緩存區(qū)，使得加載和存儲操作是亂序執(zhí)行的。

2、重排序怎么提高執(zhí)行速度

????????在不改變結(jié)果的時候，對執(zhí)行進(jìn)行重排序，可以提高處理速度。重排序后能夠使處理指令執(zhí)行的更少，減少指令操作。

3、重排序的問題所在

????????由于重排序，直接可能帶來的問題就是導(dǎo)致最終的數(shù)據(jù)不對，通過以下例子來看，如果執(zhí)行的順序不同，最終得到的結(jié)果是不一樣的。

public class Test {
    public static int a = 0, b = 0;
    public static int i = 0, j = 0;

    public static void main(String[] args) throws InterruptedException {
        int count = 0;
        while (true) {
            count++;
            // 初始化
            a = 0;
            b = 0;
            i = 0;
            j = 0;
            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    a = 1;
                    i = b;
                }
            });
            Thread two = new Thread(new Runnable() {
                @Override
                public void run() {
                    b = 1;
                    j = a;
                }
            });
            one.start();
            two.start();
            one.join(); // 確保線程都執(zhí)行完畢
            two.join();
            System.out.println("第" + count + "次線程執(zhí)行：i = " + i + ", j = " + j );
            if (i == 0 && j == 0) return;
        }
    }
}

????????正常當(dāng)線程都執(zhí)行結(jié)束之后，最后得到的值應(yīng)該是i=1, j=1。通過不斷的循環(huán)執(zhí)行可以看到，出現(xiàn)的結(jié)果會出錯，當(dāng)先執(zhí)行了j=a(此時a=0)在執(zhí)行了a=1，i=b(此時b=0)，b=1，最后就會導(dǎo)致i=0，j=0

?4、volatile禁止指令重排序

????????使用volatile可以實(shí)現(xiàn)禁止指令重排序，從而確保并發(fā)安全，那么volatile是如何實(shí)現(xiàn)禁止指令重排序呢？就是通過使用內(nèi)存屏障(Memory Barrier)。

5、內(nèi)存屏障(Memory Barrier) 作用

• 內(nèi)存屏障****能夠阻止屏障兩側(cè)的指令重排序，能夠讓cpu或者編譯器在內(nèi)存上的訪問是有序的。
• 強(qiáng)制把寫緩沖區(qū)/高速緩存中的臟數(shù)據(jù)寫回主內(nèi)存，或讓緩存相應(yīng)的數(shù)據(jù)失效。他是一種cpu指令，用來控制特定情況下的重排序和內(nèi)存可見性問題。

6、volatile內(nèi)存屏障的插入策略

硬件層的內(nèi)存屏障(Memory Barrier)有Load Barrier 和 Store Barrier即讀屏障和寫屏障。

Java內(nèi)存屏障

• StoreStore屏障：確保在該屏障之后的第一個寫操作之前，屏障前的寫操作對其他處理器可見（刷新到內(nèi)存）。
• StoreLoad屏障：確保寫操作對其他處理器可見（刷新到內(nèi)存）之后才能讀取屏障后讀操作的數(shù)據(jù)到緩存。
• LoadLoad屏障：確保在該屏障之后的第一個讀操作之前，一定能先加載屏障前的讀操作對應(yīng)的數(shù)據(jù)。
• LoadStore屏障：確保屏障后的第一個寫操作寫出的數(shù)據(jù)對其他處理器可見之前，屏障前的讀操作讀取的數(shù)據(jù)一定先讀入緩存。

????????在volatile修飾的變量進(jìn)行寫操作時候，會使用StoreStore屏障和StoreLoad屏障，進(jìn)行對volatile變量讀操作會在之后使用LoadLoad屏障和LoadStore屏障。

?四、volatile的內(nèi)存語義

內(nèi)存語義可以理解為 volatile 在執(zhí)行計算時，內(nèi)存中的要實(shí)現(xiàn)的功能與規(guī)則：

• 寫一個 volatile 變量時，JMM 會把該線程對應(yīng)的本地內(nèi)存中的共享變量值刷新到主內(nèi)存。
• 讀一個 volatile 變量時，JMM 會把該線程對應(yīng)的本地內(nèi)存置為無效，并從主內(nèi)存中讀取共享變量。

4.1、volatile 與 static

• static 修飾的變量：多實(shí)例間，保證變量的唯一性。但是沒有可見性和原子性的保證。
• volatile 修飾的變量：多實(shí)例間，變量沒有唯一性。但是能保證線程可見性，不保證原子性。

所以，static volatile 修飾的變量就是多實(shí)例間的唯一性，以及線程間的可見性。文章來源地址http://www.zghlxwxcb.cn/news/detail-609181.html

五、總結(jié)

• 適用場景：某個屬性被多個線程共享，其中有一個線程修改了此屬性，其他線程可以立即得到修改后的值，比如 booleanflag；或者作為觸發(fā)器，實(shí)現(xiàn)輕量級同步。
• volatile 變量的讀寫操作都是無鎖的，低成本的。它不能替代 synchronized，因為它沒有提供原子性和互斥性。
• volatile 只能作用于屬性，我們用volatile修飾屬性，這樣compilers就不會對這個屬性做指令重排序。
• volatile 可以在單例雙重檢查中（特殊場景）實(shí)現(xiàn)可見性和禁止指令重排序，從而保證安全性。

到了這里，關(guān)于volatile關(guān)鍵字（輕量級鎖）的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！