課程導(dǎo)言

適用對象

本課程適合已經(jīng)掌握J(rèn)ava多線程基礎(chǔ)（如Thread、Runnable、synchronized），但對并發(fā)內(nèi)部原理尚不清晰的開發(fā)者。volatile是Java并發(fā)編程中一個看似簡單、實則深邃的關(guān)鍵字——用起來只有一行代碼，理解起來卻需要深入CPU緩存模型、JMM內(nèi)存模型、指令重排序等多個底層領(lǐng)域。掌握volatile，是理解Java并發(fā)的關(guān)鍵里程碑。

學(xué)習(xí)目標(biāo)

通過本文的系統(tǒng)學(xué)習(xí)，你將能夠：

• 透徹理解 volatile的兩大核心語義：可見性保證與有序性保證
• 深入底層 從JMM、CPU緩存一致性協(xié)議到內(nèi)存屏障，看懂volatile的硬件級實現(xiàn)
• 明確邊界 知道volatile能做什么、不能做什么（尤其原子性限制）
• 熟練應(yīng)用 掌握volatile的三大經(jīng)典使用場景：狀態(tài)標(biāo)志、雙重檢查鎖、輕量級讀寫鎖
• 對比選擇 區(qū)分volatile、synchronized、Atomic*的適用場景，做出正確設(shè)計決策

第一部分：從并發(fā)三要素看volatile的定位

1.1 并發(fā)編程的三座大山

在多線程編程中，我們必須面對三個核心問題：可見性、原子性、有序性。這三大問題的根源在于現(xiàn)代計算機(jī)系統(tǒng)的硬件架構(gòu)——CPU緩存與指令優(yōu)化。

1.2 volatile的坐標(biāo)：輕量級的同步利器

volatile關(guān)鍵字在并發(fā)三要素中的定位非常清晰：

• 保證可見性：?
• 保證有序性：?
• 保證原子性：?（僅對單次讀/寫操作保證，復(fù)合操作不保證）

因此，volatile常被稱作輕量級的synchronized。它沒有鎖的獲取與釋放，不會導(dǎo)致線程阻塞，開銷遠(yuǎn)小于synchronized，但功能也相對有限。

1.3 一個先導(dǎo)案例：感受volatile的魔力

先看一個沒有volatile的程序：

public class NoVolatileDemo {
    private static boolean flag = true;  // 沒有volatile
    public static void main(String[] args) throws InterruptedException {
        Thread worker = new Thread(() -> {
            System.out.println("工作線程啟動");
            while (flag) {
                // 循環(huán)等待flag變?yōu)閒alse
            }
            System.out.println("工作線程結(jié)束");
        });
        worker.start();
        Thread.sleep(1000); // 主線程休眠1秒
        flag = false; // 修改flag
        System.out.println("主線程已將flag設(shè)為false");
    }
}

運(yùn)行這段代碼，你會發(fā)現(xiàn)一個令人困惑的現(xiàn)象：工作線程永遠(yuǎn)不會結(jié)束。盡管主線程已經(jīng)將flag修改為false，但工作線程仍然在循環(huán)中無法退出。

這就是可見性問題的典型表現(xiàn)：工作線程一直在自己的CPU緩存中讀取flag的副本，看不到主內(nèi)存中flag的變化。

現(xiàn)在，只需加上volatile：

private volatile static boolean flag = true;

再次運(yùn)行，工作線程會立即響應(yīng)flag的變化，優(yōu)雅退出。這小小的volatile背后，究竟發(fā)生了什么？讓我們一步步揭開它的面紗。

第二部分：volatile與Java內(nèi)存模型（JMM）

2.1 為什么要JMM？

要理解volatile，必須先理解Java內(nèi)存模型（Java Memory Model, JMM）。JMM是Java并發(fā)編程的"交通規(guī)則"，它定義了多線程環(huán)境下變量的訪問規(guī)范，屏蔽了不同硬件和操作系統(tǒng)的差異。

2.2 JMM的核心結(jié)構(gòu)：主內(nèi)存 vs 工作內(nèi)存

JMM規(guī)定了兩種內(nèi)存區(qū)域：

• 主內(nèi)存（Main Memory）：所有線程共享的內(nèi)存區(qū)域，存儲著所有的共享變量（實例字段、靜態(tài)字段、數(shù)組元素等）。
• 工作內(nèi)存（Working Memory）：每個線程私有的內(nèi)存區(qū)域，存儲了該線程所需變量的副本。

線程對變量的所有操作（讀取、賦值）都必須在工作內(nèi)存中進(jìn)行，不能直接讀寫主內(nèi)存。這種設(shè)計是為了性能——CPU訪問緩存的速度比訪問主內(nèi)存快幾個數(shù)量級。

┌─────────────────┐      ┌─────────────────┐      ┌─────────────────┐
│    Thread A     │      │    Thread B     │      │    Thread C     │
│  工作內(nèi)存A       │      │  工作內(nèi)存B       │      │  工作內(nèi)存C       │
│  flag副本 = true │      │  flag副本 = true │      │  flag副本 = true │
└────────┬────────┘      └────────┬────────┘      └────────┬────────┘
         │                        │                        │
         └────────────────────────┼────────────────────────┘
                                  ▼
                        ┌─────────────────┐
                        │    主內(nèi)存        │
                        │   flag = true   │
                        └─────────────────┘

2.3 可見性問題的根源

當(dāng)一個線程修改了共享變量的值，它首先修改的是自己工作內(nèi)存中的副本。如果這個新值沒有及時刷新到主內(nèi)存，或者其他線程沒有及時從主內(nèi)存重新加載，就會導(dǎo)致其他線程看到"過時"的值——這就是可見性問題的本質(zhì)。

在1.3節(jié)的案例中：

1. 工作線程啟動時，將主內(nèi)存的flag值（true）加載到自己的工作內(nèi)存
2. 工作線程循環(huán)讀取自己工作內(nèi)存中的flag副本，永遠(yuǎn)不會再從主內(nèi)存重新加載
3. 主線程將主內(nèi)存的flag修改為false，但工作線程對此一無所知

2.4 volatile如何保證可見性？

volatile變量的讀寫操作具有特殊的內(nèi)存語義：

• 對volatile變量執(zhí)行寫操作時：JVM會強(qiáng)制將當(dāng)前線程工作內(nèi)存中該變量的最新值刷新到主內(nèi)存中。
• 對volatile變量執(zhí)行讀操作時：JVM會強(qiáng)制將當(dāng)前線程工作內(nèi)存中該變量的副本置為無效，迫使線程必須從主內(nèi)存重新加載最新值。

這種機(jī)制確保了對volatile變量的任何修改，對其他所有線程都是立即可見的。

2.5 JMM對volatile的規(guī)范

JMM為volatile制定了嚴(yán)格的訪問規(guī)則：

• 寫入volatile變量時，JVM會向處理器發(fā)送一條lock前綴指令，將該變量所在緩存行的數(shù)據(jù)寫回主內(nèi)存，并使其他處理器中的對應(yīng)緩存失效。
• 讀取volatile變量時，JVM會向處理器發(fā)送一條load指令，將該變量的值從主內(nèi)存重新讀取到本地內(nèi)存。
• 在執(zhí)行volatile變量的讀寫操作時，JVM會禁止編譯器和處理器對相關(guān)指令進(jìn)行優(yōu)化重排，以保證指令的有序執(zhí)行。

第三部分：有序性與指令重排序

3.1 什么是指令重排序？

為了提升程序性能，編譯器和處理器常常會對指令進(jìn)行重新排序（Instruction Reordering）。只要重排序后的結(jié)果與單線程環(huán)境下順序執(zhí)行的結(jié)果一致，就是允許的。

重排序分為三個層面：

1. 編譯器優(yōu)化重排序：在不改變單線程語義的前提下，調(diào)整語句執(zhí)行順序。
2. 指令級并行重排序：現(xiàn)代處理器采用指令級并行技術(shù)，將多條指令重疊執(zhí)行。
3. 內(nèi)存系統(tǒng)重排序：處理器使用緩存和讀/寫緩沖區(qū)，導(dǎo)致加載和存儲操作看起來可能亂序執(zhí)行。

3.2 重排序的潛在風(fēng)險

在多線程環(huán)境下，重排序可能導(dǎo)致令人困惑的結(jié)果。經(jīng)典例子是雙重檢查鎖（DCL）單例模式中，如果沒有volatile，可能返回一個"半初始化"的對象。

// 看似正確的DCL，但存在隱患！
public class Singleton {
    private static Singleton instance;  // 沒有volatile！
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();  // 隱患在這里
                }
            }
        }
        return instance;
    }
}

問題出在instance = new Singleton()這一行。這個操作在JVM層面可以分解為三步：

memory = allocate();    // 1. 分配對象內(nèi)存空間
ctorInstance(memory);   // 2. 調(diào)用構(gòu)造函數(shù)，初始化對象
instance = memory;      // 3. 將instance引用指向內(nèi)存地址

在單線程環(huán)境下，即使2和3發(fā)生重排序（先賦值，后初始化），最終結(jié)果也一致。但在多線程環(huán)境下，這可能造成災(zāi)難：

• 線程A進(jìn)入同步塊，執(zhí)行了1→3（重排序），此時instance已經(jīng)非空，但對象尚未初始化
• 線程B執(zhí)行第一次檢查if (instance == null)，發(fā)現(xiàn)instance不為空，直接返回instance
• 線程B使用這個"半初始化"的對象，導(dǎo)致不可預(yù)料的錯誤（如NullPointerException）

3.3 volatile如何禁止重排序？

volatile通過**內(nèi)存屏障（Memory Barrier）**機(jī)制來禁止特定類型的重排序。內(nèi)存屏障是一種CPU指令，它允許你保證特定操作執(zhí)行的順序性，并保證某些數(shù)據(jù)的可見性。

3.3.1 JMM的volatile重排序規(guī)則表

JMM針對編譯器制定了volatile重排序規(guī)則表：

這張表的含義是：

• 當(dāng)?shù)诙€操作是volatile寫時，不管第一個操作是什么，都不能重排序（確保volatile寫之前的所有操作不會跑到它后面）
• 當(dāng)?shù)谝粋€操作是volatile讀時，不管第二個操作是什么，都不能重排序（確保volatile讀之后的所有操作不會跑到它前面）
• 當(dāng)?shù)谝粋€操作是volatile寫，第二個操作是volatile讀時，不能重排序

3.3.2 內(nèi)存屏障的插入策略

為了實現(xiàn)volatile的內(nèi)存語義，JVM采取保守的內(nèi)存屏障插入策略：

• 在每個volatile寫操作的前面插入一個StoreStore屏障
• 在每個volatile寫操作的后面插入一個StoreLoad屏障
• 在每個volatile讀操作的后面插入一個LoadLoad屏障
• 在每個volatile讀操作的后面插入一個LoadStore屏障

四種內(nèi)存屏障的作用：

這些屏障共同工作，確保了volatile變量操作的有序性和可見性。

第四部分：深入底層——硬件級別的實現(xiàn)

4.1 CPU緩存架構(gòu)與MESI協(xié)議

要理解volatile的底層實現(xiàn)，需要了解現(xiàn)代CPU的緩存架構(gòu)?，F(xiàn)代多核CPU通常采用多級緩存結(jié)構(gòu)（L1、L2、L3），每個核心有自己的私有緩存（L1/L2），共享最后一級緩存（L3）。

當(dāng)多個核心同時操作同一內(nèi)存地址時，如何保證緩存一致性？CPU采用了緩存一致性協(xié)議，最常見的是MESI協(xié)議。

4.2 MESI協(xié)議的狀態(tài)

MESI協(xié)議為每個緩存行定義了四種狀態(tài)：

• M（Modified，修改）：該緩存行數(shù)據(jù)被修改過，與主內(nèi)存不一致，且只存在于當(dāng)前緩存中
• E（Exclusive，獨(dú)占）：數(shù)據(jù)有效，與主內(nèi)存一致，且只存在于當(dāng)前緩存
• S（Shared，共享）：數(shù)據(jù)有效，與主內(nèi)存一致，且存在于多個緩存中
• I（Invalid，無效）：該緩存行數(shù)據(jù)無效

當(dāng)一個核心修改了處于S狀態(tài)的緩存行時，它需要通過**總線嗅探（Bus Snooping）**機(jī)制通知其他核心將該緩存行置為無效。

4.3 volatile的硬件級實現(xiàn)：lock指令 + MESI

當(dāng)我們對volatile變量進(jìn)行寫操作時，JVM會向CPU發(fā)送一條lock前綴指令。這條指令的作用是：

1. 鎖總線：lock指令會鎖定CPU的總線，確保當(dāng)前處理器獨(dú)占共享內(nèi)存（早期實現(xiàn)）
2. 緩存鎖定+緩存一致性：現(xiàn)代CPU優(yōu)化后，lock指令通常只鎖定緩存行，同時通過MESI協(xié)議保證一致性

lock指令的核心效果是：

• 將當(dāng)前處理器緩存行的數(shù)據(jù)立即寫回主內(nèi)存
• 這個寫回操作會導(dǎo)致其他CPU中對應(yīng)的緩存行失效（通過MESI協(xié)議）

當(dāng)其他核心再次讀取該變量時，發(fā)現(xiàn)自己的緩存行已失效，就會從主內(nèi)存重新加載最新值。這就是volatile保證可見性的硬件基礎(chǔ)。

4.4 lock指令與內(nèi)存屏障的關(guān)系

在x86架構(gòu)下，volatile寫操作實際上是通過帶lock前綴的寫指令實現(xiàn)的，如lock addl $0, (esp)。這個指令本身就能實現(xiàn)StoreLoad屏障的效果——既保證前面的操作已完成，又保證后面的操作不會提前。

因此，在x86平臺上，volatile的讀操作并不需要完全的內(nèi)存屏障，編譯器只需保證讀操作不被重排序即可。這也是volatile在x86上性能極高的原因之一。

第五部分：volatile的邊界——原子性缺陷

5.1 volatile不能保證復(fù)合操作的原子性

這是volatile使用中最容易犯的錯誤?？紤]一個計數(shù)器場景：

public class Counter {
    private volatile int count = 0;
    public void increment() {
        count++;  // 不是原子操作！
    }
    public int getCount() {
        return count;
    }
}

當(dāng)多個線程同時調(diào)用increment()時，count的最終值很可能小于預(yù)期值。為什么？因為count++是一個復(fù)合操作，它包含三個步驟：

1. 從主內(nèi)存讀取count的當(dāng)前值（讀）
2. 對讀取的值加1（改）
3. 將新值寫回主內(nèi)存（寫）

volatile只能保證第1步和第3步的單個操作是原子的，但無法保證這三步作為一個整體不被其他線程打斷。兩個線程可能同時讀到相同的值，各自加1后寫回，導(dǎo)致實際只增加了1次。

5.2 哪些操作是原子性的？

在Java中，以下操作具有原子性：

• 對基本類型變量（除long/double外）的賦值和讀取
• 對引用類型變量的賦值和讀取
• 對volatile修飾的long/double的賦值和讀取

但以下操作不具原子性：

• 自增/自減操作（i++、i–）
• 任何復(fù)合賦值操作（i += 2、i = i + 1）
• 先檢查后執(zhí)行的操作（if (flag) { doSomething(); }）

5.3 如何解決原子性問題？

對于需要原子性的復(fù)合操作，可以選擇：

1. 使用synchronized：通過鎖保證原子性
2. 使用ReentrantLock：功能更豐富的鎖
3. 使用原子類（Atomic*）**：如AtomicInteger，基于CAS實現(xiàn)無鎖原子操作

public class SafeCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();  // 原子自增
    }
    public int getCount() {
        return count.get();
    }
}

第六部分：volatile的經(jīng)典應(yīng)用場景

6.1 場景一：狀態(tài)標(biāo)志位

這是volatile最常見的應(yīng)用場景。當(dāng)線程A需要通知線程B某個事件已經(jīng)發(fā)生時，可以使用volatile變量作為狀態(tài)標(biāo)志。

public class ShutdownDemo {
    private volatile boolean shutdown = false;
    public void shutdown() {
        shutdown = true;  // 狀態(tài)轉(zhuǎn)換是原子操作
    }
    public void doWork() {
        while (!shutdown) {
            // 正常工作
        }
        // 清理工作
    }
}

為什么適合volatile？

• 狀態(tài)轉(zhuǎn)換是簡單的賦值操作，具有原子性
• 只需要保證可見性，不需要復(fù)合操作的原子性
• 狀態(tài)通常只從一種狀態(tài)轉(zhuǎn)換到另一種狀態(tài)（一次性），沒有復(fù)雜的依賴

6.2 場景二：雙重檢查鎖（DCL）單例模式

這是volatile最經(jīng)典、最考驗理解深度的場景。

public class DoubleCheckedLockingSingleton {
    // volatile保證可見性和禁止重排序
    private static volatile DoubleCheckedLockingSingleton instance;
    private DoubleCheckedLockingSingleton() {
        // 初始化
    }
    public static DoubleCheckedLockingSingleton getInstance() {
        if (instance == null) {  // 第一次檢查（不加鎖）
            synchronized (DoubleCheckedLockingSingleton.class) {
                if (instance == null) {  // 第二次檢查（加鎖）
                    instance = new DoubleCheckedLockingSingleton();
                }
            }
        }
        return instance;
    }
}

為什么需要volatile？

如果沒有volatile，instance = new DoubleCheckedLockingSingleton()可能發(fā)生指令重排序（先賦值，后初始化）。這會導(dǎo)致：

1. 線程A進(jìn)入同步塊，執(zhí)行了指令重排序，instance指向了未初始化的內(nèi)存
2. 線程B進(jìn)入第一次檢查，發(fā)現(xiàn)instance不為null，直接返回instance
3. 線程B使用這個半初始化的對象，導(dǎo)致不可預(yù)料的結(jié)果

volatile通過禁止重排序，確保了對instance的賦值發(fā)生在對象完全初始化之后，徹底解決了這個問題。

JDK 5+的要求：從JDK 5開始，volatile的語義得到增強(qiáng)，可以確保DCL的正確性。

6.3 場景三：獨(dú)立觀察值的發(fā)布

當(dāng)一個對象的狀態(tài)由一組volatile變量組成，且這些變量之間沒有約束關(guān)系，可以通過volatile安全地發(fā)布。

public class UserConfig {
    private volatile String theme;
    private volatile boolean notificationEnabled;
    public void updateConfig(String theme, boolean notificationEnabled) {
        this.theme = theme;  // 每個volatile變量獨(dú)立更新
        this.notificationEnabled = notificationEnabled;
    }
    public String getTheme() { return theme; }
    public boolean isNotificationEnabled() { return notificationEnabled; }
}

注意：這種方式只適用于變量之間相互獨(dú)立的場景。如果變量之間存在約束關(guān)系（如min必須小于max），就需要使用鎖或其他同步機(jī)制來保證原子性更新。

6.4 場景四：輕量級的"讀寫鎖"

可以使用volatile實現(xiàn)一種非常輕量級的讀寫鎖，適用于寫操作極少、讀操作極多的場景。

public class LightweightReadWriteLock {
    private volatile int value;
    // 讀操作：無鎖
    public int getValue() {
        return value;
    }
    // 寫操作：使用synchronized保護(hù)
    public synchronized void setValue(int newValue) {
        this.value = newValue;
    }
}

這種模式結(jié)合了volatile的可見性和synchronized的原子性，在讀多寫少的場景下性能極佳。

第七部分：volatile與相關(guān)機(jī)制的對比

7.1 volatile vs synchronized

7.2 volatile vs Atomic*（原子類）

選擇建議：

• 需要復(fù)合操作的原子性（如i++），使用AtomicInteger
• 需要狀態(tài)標(biāo)志，使用volatile
• 需要原子更新引用對象，使用AtomicReference

7.3 volatile vs final

對于不可變對象，final是更好的選擇。JMM對final字段有特殊的初始化保證，可以確保對象在構(gòu)造完成前不會被其他線程看到。

7.4 性能對比

在大多數(shù)情況下，volatile的性能優(yōu)于synchronized，原因在于：

• volatile不需要獲取鎖，不會導(dǎo)致線程阻塞和上下文切換
• volatile在用戶態(tài)執(zhí)行，不涉及內(nèi)核態(tài)切換
• volatile僅影響特定內(nèi)存地址，不鎖總線

但需要注意的是，volatile的性能也并非零開銷。頻繁的volatile寫入會導(dǎo)致緩存刷新和一致性消息傳遞，在高并發(fā)場景下仍可能成為瓶頸。

第八部分：volatile常見陷阱與最佳實踐

8.1 陷阱一：誤以為volatile保證原子性

// ? 錯誤示例
private volatile int counter = 0;
public void increment() {
    counter++; // 不是原子操作！
}

修正：使用AtomicInteger或synchronized。

8.2 陷阱二：復(fù)合狀態(tài)更新

// ? 錯誤示例
private volatile int x, y;
public void update(int newX, int newY) {
    this.x = newX; // 先更新x
    this.y = newY; // 再更新y
}

如果x和y必須同時更新（存在約束關(guān)系），這種寫法有問題：其他線程可能看到x已更新但y未更新的中間狀態(tài)。

修正：使用鎖保護(hù)復(fù)合狀態(tài)更新。

8.3 陷阱三：依賴volatile的"順序性"保證

// ? 可能有問題的代碼
volatile int a = 0;
int b = 0;
public void write() {
    a = 1;    // volatile寫
    b = 2;    // 普通寫
}

雖然volatile寫可以防止a=1和b=2的重排序，但無法保證b=2對其他線程的可見性。如果另一個線程先讀取a，再讀取b，可能看到a=1但b=0。

8.4 陷阱四：在復(fù)合檢查中使用volatile

// ? 錯誤示例
private volatile boolean initialized = false;
private Configuration config;
public void init() {
    if (!initialized) {
        config = loadConfig();
        initialized = true;
    }
}

這不是線程安全的，多個線程可能同時進(jìn)入if塊。需要synchronized保護(hù)整個檢查-初始化過程。

8.5 最佳實踐總結(jié)

1. 明確需求：是否需要原子性？如果需要，不要用volatile
2. 單一職責(zé)：volatile變量應(yīng)獨(dú)立于其他變量和約束
3. 狀態(tài)簡單：狀態(tài)轉(zhuǎn)換應(yīng)該是簡單的賦值操作
4. 適當(dāng)配合：volatile常與synchronized、Atomic*結(jié)合使用
5. 考慮替代：對于不可變對象，優(yōu)先使用final

8.6 檢查清單

第九部分：volatile面試高頻題解析

Q1：volatile能否保證數(shù)組的可見性？

答：volatile修飾數(shù)組變量，只能保證數(shù)組引用本身的可見性，不能保證數(shù)組元素的可見性。例如：

private volatile int[] array = new int[10];

array引用是volatile的，但array[0]的修改對其他線程不可見。解決方案：使用AtomicIntegerArray。

Q2：64位long/double的讀寫是否是原子的？

在32位JVM上，long/double的讀寫可能分為兩個32位操作，不是原子的。但使用volatile修飾后，其讀寫變成原子的。

Q3：volatile能代替鎖嗎？

答：不能完全替代。鎖能保證原子性、可見性和有序性，而volatile只保證后兩者。對于復(fù)合操作，必須使用鎖或原子類。

Q4：volatile在單例模式中的作用是什么？

答：volatile在DCL單例中有兩個作用：

1. 禁止指令重排序，防止返回半初始化的對象
2. 保證可見性，確保一個線程創(chuàng)建的實例對其他線程可見

Q5：happens-before規(guī)則中關(guān)于volatile的規(guī)定是什么？

答：對一個volatile變量的寫操作，happens-before于任意后續(xù)對這個volatile變量的讀操作。這意味著線程A寫完volatile變量后，線程B讀取該變量時，能看到A在寫操作之前的所有操作結(jié)果。

課程總結(jié)

知識體系回顧

通過本文的系統(tǒng)學(xué)習(xí)，我們?nèi)嬲莆樟藇olatile關(guān)鍵字：

• 核心語義：
  • 可見性：寫操作強(qiáng)制刷新主內(nèi)存，讀操作強(qiáng)制從主內(nèi)存加載
  • 有序性：通過內(nèi)存屏障禁止特定類型的指令重排序
• 底層原理：
  • JMM層面：工作內(nèi)存與主內(nèi)存的交互規(guī)則
  • 硬件層面：lock前綴指令 + MESI緩存一致性協(xié)議
• 應(yīng)用邊界：
  • ? 狀態(tài)標(biāo)志、DCL單例、獨(dú)立觀察值
  • ? 計數(shù)器、累加器、復(fù)合狀態(tài)更新
• 對比選擇：
  • 原子性需求 → synchronized或Atomic*
  • 可見性需求 → volatile
  • 讀多寫少 → volatile + synchronized組合

一句話總結(jié)

volatile是Java并發(fā)編程的"輕騎兵"：它以輕量級的開銷，解決了可見性和有序性問題，但開發(fā)者必須清楚它的原子性邊界，才能駕馭得當(dāng)。

到此這篇關(guān)于Java中的Volatile 關(guān)鍵字從底層原理到最佳實踐案例的文章就介紹到這了,更多相關(guān)Java Volatile 關(guān)鍵字原理內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論