切換語言為:簡體

在 Java 中 使用單例模式建立物件時為什麼一定要加volatile?

  • 爱糖宝
  • 2024-07-31
  • 2070
  • 0
  • 0

單例模式的實現方法有很多種,如餓漢模式、懶漢模式、靜態內部類和列舉等,當面試官問到“為什麼單例模式一定要加 volatile?”時,那麼他指的是為什麼懶漢模式中的私有變數要加 volatile?

懶漢模式指的是物件的建立是懶載入的方式,並不是在程式啟動時就建立物件,而是第一次被真正使用時才建立物件。

要解釋為什麼要加 volatile?我們先來看懶漢模式的具體實現程式碼:

public class Singleton {
    // 1.防止外部直接 new 物件破壞單例模式
    private Singleton() {}
    // 2.透過私有變數儲存單例物件【新增了 volatile 修飾】
    private static volatile Singleton instance = null;
    // 3.提供公共獲取單例物件的方法
    public static Singleton getInstance() {
        if (instance == null) { // 第 1 次效驗
            synchronized (Singleton.class) {
            	if (instance == null) { // 第 2 次效驗
                	instance = new Singleton(); 
                }
            }
        }
        return instance;
    }
    }

從上述程式碼可以看出,爲了保證執行緒安全和高效能,程式碼中使用了兩次 if 和 synchronized 來保證程式的執行。那既然已經有 synchronized 來保證執行緒安全了,為什麼還要給變數加 volatile 呢?

在解釋這個問題之前,我們先要搞懂一個前置知識:volatile 有什麼用呢?

# 1.volatile 作用

volatile 有兩個主要的作用,第一,解決記憶體可見性問題,第二,防止指令重排序。

# 1.1 記憶體可見性問題

所謂記憶體可見性問題,指的是多個執行緒同時操作一個變數,其中某個執行緒修改了變數的值之後,其他執行緒感知不到變數的修改,這就是記憶體可見性問題。而使用 volatile 就可以解決記憶體可見性問題,比如以下程式碼,當沒有新增 volatile 時,它的實現如下:

private static boolean flag = false;public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            // 如果 flag 變數為 true 就終止執行
            while (!flag) {

            }
            System.out.println("終止執行");
        }
    });
    t1.start();
    // 1s 之後將 flag 變數的值修改爲 true
    Thread t2 = new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("設定 flag 變數的值為 true!");
            flag = true;
        }
    });
    t2.start();
    }

以上程式的執行結果如下: 

在 Java 中 使用單例模式建立物件時為什麼一定要加volatile?

 然而,以上程式執行了 N 久之後,依然沒有結束執行,這說明執行緒 2 在修改了 flag 變數之後,執行緒 1 根本沒有感知到變數的修改。 那麼接下來,我們嘗試給 flag 加上 volatile,實現程式碼如下:

public class volatileTest {
    private static volatile boolean flag = false;
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                // 如果 flag 變數為 true 就終止執行
                while (!flag) {

                }
                System.out.println("終止執行");
            }
        });
        t1.start();
        // 1s 之後將 flag 變數的值修改爲 true
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("設定 flag 變數的值為 true!");
                flag = true;
            }
        });
        t2.start();
    }
    }

以上程式的執行結果如下: 

在 Java 中 使用單例模式建立物件時為什麼一定要加volatile?

 從上述執行結果我們可以看出,使用 volatile 之後就可以解決程式中的記憶體可見性問題了。

# 1.2 防止指令重排序

指令重排序是指在程式執行過程中,編譯器或 JVM 常常會對指令進行重新排序,已提高程式的執行效能。 指令重排序的設計初衷確實很好,在單執行緒中也能發揮很棒的作用,然而在多執行緒中,使用指令重排序就可能會導致執行緒安全問題了。

所謂執行緒安全問題是指程式的執行結果,和我們的預期不相符。比如我們預期的正確結果是 0,但程式的執行結果卻是 1,那麼這就是執行緒安全問題。

而使用 volatile 可以禁止指令重排序,從而保證程式在多執行緒執行時能夠正確執行。

# 2.為什麼要用 volatile?

回到主題,我們在單例模式中使用 volatile,主要是使用 volatile 可以禁止指令重排序,從而保證程式的正常執行。這裏可能會有讀者提出疑問,不是已經使用了 synchronized 來保證執行緒安全嗎?那為什麼還要再加 volatile 呢?看下面的程式碼:

public class Singleton {
    private Singleton() {}
    // 使用 volatile 禁止指令重排序
    private static volatile Singleton instance = null;
    public static Singleton getInstance() {
        if (instance == null) { // ①
            synchronized (Singleton.class) {
            	if (instance == null) {
                	instance = new Singleton(); // ②
                }
            }
        }
        return instance;
    }
    }

注意觀察上述程式碼,我標記了第 ① 處和第 ② 處的兩行程式碼。給私有變數加 volatile 主要是爲了防止第 ② 處執行時,也就是“instance = new Singleton()”執行時的指令重排序的,這行程式碼看似只是一個建立物件的過程,然而它的實際執行卻分為以下 3 步:

  1. 建立記憶體空間。

  2. 在記憶體空間中初始化物件 Singleton。

  3. 將記憶體地址賦值給 instance 物件(執行了此步驟,instance 就不等於 null 了)。

試想一下,如果不加 volatile,那麼執行緒 1 在執行到上述程式碼的第 ② 處時就可能會執行指令重排序,將原本是 1、2、3 的執行順序,重排為 1、3、2。但是特殊情況下,執行緒 1 在執行完第 3 步之後,如果來了執行緒 2 執行到上述程式碼的第 ① 處,判斷 instance 物件已經不為 null,但此時執行緒 1 還未將物件例項化完,那麼執行緒 2 將會得到一個被例項化“一半”的物件,從而導致程式執行出錯,這就是為什麼要給私有變數新增 volatile 的原因了。

# 小結

使用 volatile 可以解決記憶體可見性問題和防止指令重排序,我們在單例模式中使用 volatile 主要是使用 volatile 的後一個特性(防止指令重排序),從而避免多執行緒執行的情況下,因為指令重排序而導致某些執行緒得到一個未被完全例項化的物件,從而導致程式執行出錯的情況。

0則評論

您的電子郵件等資訊不會被公開,以下所有項目均必填

OK! You can skip this field.