認識 Java 的 volatile 關鍵字及指令重排

在多線程編程中，volatile 關鍵字是確保變量在多個線程之間可見的重要工具，它還能幫助防止指令重排。下面，我們將詳細解釋這些概念，並通過實際例子說明 volatile 的使用場景和局限性。

可見性

在多線程環境中，一個線程對共享變量的修改可能不會被其他線程立即看到。這是因為線程可能會將變量的值緩存，而不是直接從主內存中讀取。例如：

class SharedObject {
    private boolean flag = false;

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

    public boolean getFlag() {
        return this.flag;
    }
}

假設線程 A 調用 setFlag() 方法將 flag 設置為 true，而線程 B 調用 getFlag() 方法檢查 flag 的值。在沒有使用 volatile 的情況下，線程 B 可能看不到線程 A 對 flag 的修改，因為 flag 的更新可能只存在於線程 A 的緩存中，而沒有同步到主內存。

volatile 如何解決可見性問題

通過將變量聲明為 volatile，可以確保對這個變量的所有修改對所有線程都是可見的：

class SharedObject {
    private volatile boolean flag = false;

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

    public boolean getFlag() {
        return this.flag;
    }
}

在這個例子中，flag 被聲明為 volatile，這意味著每次對 flag 的寫操作都會立刻更新到主內存，任何線程讀取 flag 的值時都會直接從主內存中獲取最新的值，從而確保了變量的可見性。

volatile 的局限性

雖然 volatile 能保證可見性，但它不能保證操作的原子性。原子性意味著操作要麼全部成功，要麼不成功。例如，以下代碼中的 count++ 操作並不是原子的：

class Counter {
    private volatile int count = 0;

    public void increment() {
        count++;
    }
}

count++ 實際上包含三個步驟：

讀取 count 的值。
增加值。
寫回 count。

如果兩個線程同時執行 increment() 方法，它們可能會讀取到相同的 count 值，然後分別增加這個值，最終導致 count 的值少於實際增加的次數。

如何保證原子性

要保證操作的原子性，可以使用 synchronized 或 AtomicInteger 類：

使用 synchronized：

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }
}

使用 synchronized 可以確保同一時刻只有一個線程能夠執行 increment() 方法，從而保證 count++ 操作的原子性。

使用 AtomicInteger：

import java.util.concurrent.atomic.AtomicInteger;

class Counter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet();
    }
}

AtomicInteger 提供了原子操作的方法，如 incrementAndGet()，可以安全地進行並發操作。

指令重排

指令重排是編譯器和 CPU 為了優化性能而對代碼指令執行順序進行的調整。這可能導致在多線程環境中出現意外行為。例如：

class Example {
    private int x = 0;
    private boolean flag = false;

    public void method1() {
        x = 1;
        flag = true;
    }

    public void method2() {
        if (flag) {
            System.out.println(x);
        }
    }
}

在沒有使用 volatile 的情況下，編譯器或 CPU 可能將 flag = true 和 x = 1 的執行順序調整，從而可能導致 method2 中的 flag 已變為 true 但 x 還未更新。

volatile 如何處理指令重排

volatile 關鍵字可以防止對 volatile 變量的指令重排。使用關鍵字後，寫操作不會被重排到讀操作之前，讀操作不會被重排到寫操作之後，從而避免了指令重排帶來的問題：

class Example {
    private volatile int x = 0;
    private volatile boolean flag = false;

    public void method1() {
        x = 1;
        flag = true;
    }

    public void method2() {
        if (flag) {
            System.out.println(x);
        }
    }
}

在這個例子中，flag 和 x 都被聲明為 volatile，這樣可以確保 method1 中的 flag = true 不會被重排到 x = 1 之前，從而在 method2 中可以正確地讀取到 x 的最新值。

一句話

volatile 是 Java 中一個重要的工具，確保變量在多線程中對所有線程都是可見的，並防止指令重排。然而，它不能保證操作的原子性。在需要保證原子性的場景中，考慮使用 synchronized 或 AtomicInteger。

此文由 Mix Space 同步更新至 xLog
原始鏈接為 https://me.liuyaowen.club/posts/default/20240821and2