大家好，我是栗箏i，這篇文章是我的 “栗箏i 的 Java 技術(shù)棧” 專欄的第 026 篇文章，在 “栗箏i 的 Java 技術(shù)棧” 這個專欄中我會持續(xù)為大家更新 Java 技術(shù)相關(guān)全套技術(shù)棧內(nèi)容。專欄的主要目標是已經(jīng)有一定 Java 開發(fā)經(jīng)驗，并希望進一步完善自己對整個 Java 技術(shù)體系來充實自己的技術(shù)棧的同學(xué)。與此同時，本專欄的所有文章，也都會準備充足的代碼示例和完善的知識點梳理，因此也十分適合零基礎(chǔ)的小白和要準備工作面試的同學(xué)學(xué)習(xí)。當然，我也會在必要的時候進行相關(guān)技術(shù)深度的技術(shù)解讀，相信即使是擁有多年 Java 開發(fā)經(jīng)驗的從業(yè)者和大佬們也會有所收獲并找到樂趣。

–

在現(xiàn)代多線程編程中，確保數(shù)據(jù)的一致性和正確性是至關(guān)重要的。Java 作為一種廣泛使用的編程語言，為多線程編程提供了豐富的工具和機制，其中 volatile 關(guān)鍵字是一個關(guān)鍵的概念。volatile 關(guān)鍵字在 Java 中被用來修飾變量，以確保它們在多線程環(huán)境下的可見性和有序性，但它并不保證操作的原子性。

理解 volatile 的工作原理及其應(yīng)用場景，對于編寫高效和可靠的多線程程序至關(guān)重要。在本文中，我們將深入探討 volatile 關(guān)鍵字的核心特性，解釋它如何確保變量的可見性和有序性，以及它在解決多線程問題中的局限性。我們還將通過示例展示如何在實際編程中使用 volatile，以及如何通過其他同步機制來彌補 volatile 的不足。

通過對 volatile 的詳細分析，我們希望讀者能夠更好地理解在多線程環(huán)境中變量訪問的復(fù)雜性，并掌握在實際開發(fā)中如何正確使用 volatile 關(guān)鍵字，以編寫出更加健壯和高效的并發(fā)程序。

1、volatile 關(guān)鍵字簡介

volatile 關(guān)鍵字在 Java 中用于修飾變量，使其具有可見性和有序性。

• 可見性：在多線程環(huán)境下，當一個線程修改了 volatile 變量的值，新值對于其他線程是立即可見的。通常情況下，線程之間對變量的讀寫操作是不可見的，這意味著一個線程修改了變量的值，另一個線程可能看不到這個修改，仍然使用舊值。使用 volatile 關(guān)鍵字可以確保所有線程看到的是變量的最新值；
• 有序性：volatile 關(guān)鍵字還可以防止指令重排序優(yōu)化。編譯器和處理器通常會對指令進行重排序，以提高性能，但這種重排序可能會破壞多線程程序的正確性。volatile 變量的讀寫操作不會被重排序，也不會與前后的讀寫操作發(fā)生重排序。

需要注意的是 volatile 僅能保證可見性和有序性，不能保證原子性。例如，volatile int count 的遞增操作 count++ 仍然不是線程安全的，因為它包含了讀和寫兩個操作，可能會被其他線程打斷。

在復(fù)雜的同步場景中，可能需要使用 synchronized 或其他并發(fā)工具來確保線程安全。

2、volatile 保證可見性

在多線程編程中，線程之間共享變量的訪問可能會出現(xiàn)可見性問題，即一個線程對變量的修改可能不會被其他線程立即看到。Java 提供了 volatile 關(guān)鍵字來解決這種可見性問題。

2.1、什么是可見性問題

當一個線程修改了某個變量的值，如果這個修改對其他線程是不可見的，可能會導(dǎo)致程序出現(xiàn)非預(yù)期的行為。例如，一個線程修改了變量 flag 的值，但其他線程仍然讀取的是舊值：

public class VisibilityProblem {
    private boolean flag = true;
    public void stop() {
        flag = false;
    }
    public void run() {
        while (flag) {
            // 執(zhí)行任務(wù)
        }
    }
}

在這個例子中，如果 flag 變量沒有被聲明為 volatile，當一個線程調(diào)用 stop 方法將 flag 設(shè)置為 false 后，另一個正在運行 run 方法的線程可能無法立即看到這個變化，仍然會在 while (flag) 循環(huán)中繼續(xù)執(zhí)行。

2.2、volatile 如何保證可見性

volatile 關(guān)鍵字通過以下機制確保變量的可見性：

• 內(nèi)存可見性協(xié)議：
  • 每個線程都有自己的本地緩存，當一個線程對變量進行讀寫操作時，實際上是從本地緩存中讀取或?qū)懭氲?，而不是直接操作主?nèi)存中的變量。
  • 當一個變量被聲明為 volatile 時，所有線程對該變量的讀寫操作都將直接操作主內(nèi)存，而不是使用本地緩存。
  • 當一個線程修改了 volatile 變量的值，這個新值會立即刷新到主內(nèi)存中。
  • 任何線程在讀取 volatile 變量時，都會從主內(nèi)存中讀取最新的值，而不是從本地緩存中讀取舊值。
• 內(nèi)存屏障：
  • volatile 關(guān)鍵字在底層實現(xiàn)中，會在變量的讀寫操作前后插入內(nèi)存屏障（Memory Barrier）。
  • 內(nèi)存屏障確保了指令的執(zhí)行順序，防止編譯器和處理器對 volatile 變量的讀寫操作進行重排序。
  • 寫內(nèi)存屏障：確保在寫 volatile 變量之前的所有寫操作都已經(jīng)完成，并且結(jié)果對其他線程可見。
  • 讀內(nèi)存屏障：確保在讀 volatile 變量之后的所有讀操作都能讀取到最新的值。

示例代碼：

public class VolatileExample {
    private volatile boolean running = true;
    public void stop() {
        running = false;
    }
    public void run() {
        while (running) {
            // 執(zhí)行任務(wù)
        }
    }
    public static void main(String[] args) {
        VolatileExample example = new VolatileExample();
        Thread thread = new Thread(example::run);
        thread.start();
        try {
            Thread.sleep(1000); // 讓線程運行一段時間
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        example.stop(); // 停止線程
    }
}

在這個例子中，running 變量被聲明為 volatile，確保 stop 方法對 running 的修改能夠立即被 run 方法中的循環(huán)檢測到。

3、volatile 保證有序性

在多線程編程中，指令重排序（Instruction Reordering）可能會導(dǎo)致程序的執(zhí)行順序與代碼的書寫順序不一致，從而引發(fā)不可預(yù)測的問題。volatile 關(guān)鍵字通過內(nèi)存屏障（Memory Barrier）機制，防止指令重排序，確保代碼執(zhí)行的有序性。

3.1、什么是指令重排序

為了優(yōu)化程序的執(zhí)行速度，編譯器和處理器會對指令進行重排序。重排序包括以下三種類型：

• 編譯器重排序：編譯器在生成機器指令時，可以重新安排代碼的執(zhí)行順序。
• 處理器重排序：處理器可以在運行時對指令進行重排序，以充分利用處理器流水線。
• 內(nèi)存系統(tǒng)重排序：由于緩存、寫緩沖區(qū)等原因，內(nèi)存操作的順序可能與程序代碼的順序不同。

盡管重排序不會改變單線程程序的語義，但在多線程環(huán)境下，重排序可能會導(dǎo)致線程間的操作順序不一致，從而引發(fā)數(shù)據(jù)競爭和線程安全問題。

3.2、volatile 如何保證有序性

volatile 關(guān)鍵字通過插入內(nèi)存屏障，確保指令的執(zhí)行順序。內(nèi)存屏障是一種同步機制，防止特定類型的指令在重排序時被移動到屏障的另一側(cè)。volatile 變量的讀寫操作前后會插入內(nèi)存屏障，確保有序性：

• 寫內(nèi)存屏障（Store Barrier）：在寫 volatile 變量之前插入，確保在此屏障之前的所有寫操作都已完成，并且結(jié)果對其他線程可見；
• 讀內(nèi)存屏障（Load Barrier）：在讀 volatile 變量之后插入，確保在此屏障之后的所有讀操作能讀取到最新的值。

具體而言，volatile 保證了以下兩點：

寫 volatile 變量之前的所有寫操作不會被重排序到 volatile 寫之后；讀 volatile 變量之后的所有讀操作不會被重排序到 volatile 讀之前。

示例代碼：

public class VolatileOrderingExample {
    private volatile boolean flag = false;
    private int a = 0;
    public void writer() {
        a = 1;         // 寫普通變量
        flag = true;   // 寫volatile變量
    }
    public void reader() {
        if (flag) {    // 讀volatile變量
            int i = a; // 讀普通變量
            // `i` 將是 1，因為 `flag` 為 true 時，`a` 必定已經(jīng)被寫為 1
        }
    }
}

在這個例子中，writer 方法中對 a 的寫操作不會被重排序到 flag 之后，因此在 reader 方法中，一旦檢測到 flag 為 true，就能確保讀取到的 a 的值是最新的 1。

4、volatile 不保證原子性的詳細介紹

在多線程編程中，volatile 關(guān)鍵字可以保證變量的可見性和有序性，但不能保證操作的原子性。原子性（Atomicity）指的是操作在執(zhí)行過程中不可分割，要么全部執(zhí)行，要么全部不執(zhí)行。

4.1、什么是原子性問題

在多線程環(huán)境下，非原子操作可能會導(dǎo)致數(shù)據(jù)不一致。例如，自增操作 i++ 看似簡單，但它實際上由三步組成：

• 讀取變量 i 的當前值；
• 將 i 的值加 1；
• 將新值寫回 i。

這三步操作在多線程環(huán)境下可能會被打斷，從而導(dǎo)致數(shù)據(jù)競爭問題。假設(shè)兩個線程同時執(zhí)行 i++ 操作：

• 線程 A 讀取 i 的值為 5。
• 線程 B 讀取 i 的值為 5。
• 線程 A 將 i 的值加 1 并寫回，i 的值變?yōu)?6。
• 線程 B 將 i 的值加 1 并寫回，i 的值變?yōu)?6。

最終結(jié)果是，雖然兩個線程都執(zhí)行了 i++ 操作，但 i 的值只增加了 1。這就是因為 i++ 操作不是原子的。

4.2、volatile 的局限性

volatile 僅能確保變量的可見性和有序性，但不能確保操作的原子性。換句話說，使用 volatile 修飾的變量雖然可以在多個線程之間及時同步，但多個線程對該變量的復(fù)合操作（如自增、自減）仍然會存在數(shù)據(jù)競爭問題。

以下是一個例子，說明了 volatile 不保證原子性的問題：

public class VolatileNonAtomic {
    private volatile int count = 0;
    public void increment() {
        count++;
    }
    public static void main(String[] args) throws InterruptedException {
        VolatileNonAtomic example = new VolatileNonAtomic();
        Runnable task = () -> {
            for (int i = 0; i < 1000; i++) {
                example.increment();
            }
        };
        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("Final count: " + example.count);
    }
}

在這個例子中，盡管 count 變量被聲明為 volatile，但由于 increment 方法中的 count++ 操作不是原子的，最終的 count 值可能小于 2000。

4.3、解決方法

為了確保操作的原子性，可以使用以下方法：

使用 synchronized 關(guān)鍵字：將操作包裝在同步塊中，確保操作的原子性。

public class SynchronizedExample {
    private int count = 0;
    public synchronized void increment() {
        count++;
    }
}

使用原子類：Java 提供了 java.util.concurrent.atomic 包中的原子類（如 AtomicInteger、AtomicLong）來確保操作的原子性。

import java.util.concurrent.atomic.AtomicInteger;
public class AtomicExample {
    private AtomicInteger count = new AtomicInteger(0);
    public void increment() {
        count.incrementAndGet();
    }
}

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

最新評論