Warum muss das Schlüsselwort volatile zum Java-Singleton-Modus hinzugefügt werden?

Vorwort:

Es gibt viele Möglichkeiten, den Singleton-Modus zu implementieren, z. B. den Hungrigen Modus, den Lazy-Modus, statische innere Klassen und Aufzählungen usw. Als der Interviewer fragte: „Warum muss der Singleton-Modus hinzugefügt werden?“ „flüchtig?“, dann bezieht er sich darauf, warum private Variablen im Lazy-Modus flüchtig sein müssen?

Der Lazy-Modus bezieht sich auf die Lazy-Loading-Methode der Objekterstellung. Das Objekt wird nicht beim Start des Programms erstellt, sondern nur, wenn es tatsächlich zum ersten Mal verwendet wird.

Müssen Sie erklären, warum flüchtige Stoffe hinzugefügt werden? Schauen wir uns zunächst den spezifischen Implementierungscode des Lazy-Modus an:

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;
    }
}

Wie aus dem obigen Code ersichtlich ist, werden if und synchronisiert im Code zweimal verwendet, um die Thread-Sicherheit und hohe Leistung sicherzustellen, um die Ausführung sicherzustellen Programm. Da es also bereits eine Synchronisierung gibt, um die Thread-Sicherheit zu gewährleisten, warum müssen wir der Variablen volatile hinzufügen? Bevor wir dieses Problem erklären, müssen wir zunächst ein erforderliches Wissen verstehen: Wozu dient flüchtig?

1. Volatile-Funktion

volatile hat zwei Hauptfunktionen: Erstens löst es das Problem der Speichersichtbarkeit und zweitens verhindert es die Neuordnung von Anweisungen.

1.1 Speichersichtbarkeitsproblem

Das sogenannte Speichersichtbarkeitsproblem bezieht sich darauf, dass mehrere Threads eine Variable gleichzeitig bearbeiten. Nachdem ein Thread den Wert der Variablen geändert hat, können andere Threads die Änderung der Variablen nicht erkennen Es handelt sich um Probleme mit der Sichtbarkeit des Speichers. Die Verwendung von Volatilität kann das Problem der Speichersichtbarkeit lösen Wenn beispielsweise Volatilität nicht hinzugefügt wird, lautet seine Implementierung wie folgt:

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();
}

Die Ausführungsergebnisse des obigen Programms lauten wie folgt:

Das obige Programm wurde jedoch nach N langer Ausführung immer noch nicht beendet, was bedeutet, dass Thread 1 die Änderung der Variablen überhaupt nicht wahrnahm, nachdem Thread 2 die Flag-Variable geändert hatte.

Dann versuchen wir, dem Flag volatile hinzuzufügen. Der Implementierungscode lautet wie folgt:

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();
    }
}

Die Ausführungsergebnisse des obigen Programms lauten wie folgt:

Aus den obigen Ausführungsergebnissen: Wir können das nach der Verwendung von volatile sehen Es ist möglich, das Problem der Speichersichtbarkeit im Programm zu lösen.

1.2 Neuordnung von Anweisungen verhindern

Neuordnung von Anweisungen bedeutet, dass der Compiler oder die JVM während der Programmausführung häufig Anweisungen neu anordnet, um die Ausführungsleistung des Programms zu verbessern. Die ursprüngliche Entwurfsabsicht der Befehlsneuordnung ist in der Tat sehr gut und kann auch in einem einzelnen Thread eine große Rolle spielen. In Multithreads kann die Verwendung der Befehlsneuordnung jedoch zu Thread-Sicherheitsproblemen führen.

Das sogenannte Thread-Sicherheitsproblem bedeutet, dass die Ausführungsergebnisse des Programms nicht unseren Erwartungen entsprechen. Wenn beispielsweise das erwartete korrekte Ergebnis 0 ist, das Ausführungsergebnis des Programms jedoch 1 ist, handelt es sich um ein Thread-Sicherheitsproblem.

Die Verwendung von volatile kann die Neuordnung von Anweisungen verhindern und so sicherstellen, dass das Programm korrekt ausgeführt werden kann, wenn es in mehreren Threads ausgeführt wird.

2. Warum flüchtig verwenden?

Zurück zum Thema: Wir verwenden flüchtig im Singleton-Modus, hauptsächlich weil flüchtig die Neuordnung von Anweisungen verhindern und so den normalen Betrieb des Programms sicherstellen kann. Einige Leser stellen hier möglicherweise Fragen: Wird die Synchronisierung nicht bereits verwendet, um die Thread-Sicherheit zu gewährleisten? Warum also Volatilität hinzufügen? Schauen Sie sich den Code unten an:

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;
    }
}

Achten Sie auf den obigen Code. Ich habe die beiden Codezeilen bei ① und ② markiert. Das Hinzufügen von volatile zu privaten Variablen dient hauptsächlich dazu, die Neuordnung von Anweisungen während der Ausführung von ② zu verhindern, d. h. die Ausführung von „instance = new Singleton()“. Diese Codezeile scheint nur ein Prozess zum Erstellen eines Objekts zu sein. aber seine tatsächliche Ausführung ist in die folgenden 3 Schritte unterteilt:

• Speicherplatz schaffen.

• Initialisieren Sie das Objekt Singleton im Speicherbereich.

• Weisen Sie die Speicheradresse dem Instanzobjekt zu (nach Ausführung dieses Schritts ist die Instanz nicht gleich Null).

Stellen Sie sich vor: Wenn flüchtig nicht hinzugefügt wird, führt Thread 1 möglicherweise eine Neuordnung der Anweisungen durch, wenn er ② des obigen Codes ausführt, und ordnet die ursprüngliche Ausführungsreihenfolge von 1, 2 und 3 in 1, 3, 2 um . Wenn jedoch unter besonderen Umständen Thread 1 den ersten Schritt des obigen Codes ausführt, nachdem Thread 1 Schritt 3 ausgeführt hat, wird festgestellt, dass das Instanzobjekt nicht null ist, Thread 1 die Instanziierung des Objekts jedoch noch nicht abgeschlossen hat Thread 2 erhält ein „halbes“ Objekt, das instanziiert wird, was zu einem Fehler bei der Programmausführung führt. Aus diesem Grund wird volatile zur privaten Variablen hinzugefügt.

Das obige ist der detaillierte Inhalt vonWarum muss das Schlüsselwort volatile zum Java-Singleton-Modus hinzugefügt werden?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!