Die Verwendung und Vorsichtsmaßnahmen des Schlüsselworts volatile in Java

In diesem Artikel werden hauptsächlich relevante Informationen zur Verwendung des flüchtigen Java-Schlüsselworts und Vorsichtsmaßnahmen vorgestellt. Wenn eine Variable als flüchtig deklariert wird, stellt das Java-Speichermodell sicher, dass alle Threads, die die Variable verwenden, denselben und konsistenten Wert sehen können. , Freunde in Not können sich auf

Verwendung und Vorsichtsmaßnahmen für flüchtige Schlüsselwörter in Java beziehen

Was ist das flüchtige Schlüsselwort?

flüchtige Schlüsselwort Das Schlüsselwort spielt in Multithread-Programmen eine wichtige Rolle. Wenn mehrere Threads mit derselben Variablen arbeiten, verfügt jeder Thread über eine lokale Cache-Kopie dieser Variablen. Wenn ein Thread den Wert dieser Variablen ändert, ändert er daher tatsächlich den Variablenwert in seinem lokalen Cache Im Hauptspeicher wissen andere Threads, die diese Variable bedienen, nicht, dass der Wert dieser Variablen geändert wurde. Um diese Situation zu vermeiden, können wir diese Variable mit dem Schlüsselwort volatile deklarieren. Nach der Deklaration dieser Variablen wird die Variable nicht im lokalen Cache, sondern im Hauptspeicher gespeichert Der aktualisierte Wert wird im Hauptspeicher aktualisiert, und dann können andere Threads auf den aktualisierten Wert zugreifen. Wenn eine Variable als flüchtig deklariert wird, stellt das Java-Speichermodell sicher, dass alle Threads, die die Variable verwenden, denselben, konsistenten Wert sehen.

Volatile-Schlüsselwort verwendet

Erstellen Sie zunächst die VolatileData-Klasse. Der Code lautet wie folgt:

public class VolatileData {

  //声明为volatile类型
  private volatile int counter = 0;

  /**
  * 返回counter变量的值
  * @return
  */
  public int getCounter() {
    return counter;
  }

  /**
  * 自增counter变量的值
  */
  public void increaseCounter() {
    ++counter;
  }
}

Weiter Erstellen Sie als Nächstes die VolatileThread-Klasse. Der Code lautet wie folgt:

public class VolatileThread extends Thread {
  private final VolatileData volatileData;

  public VolatileThread(VolatileData volatileData) {
    this.volatileData = volatileData;
  }

  /**
  * 调用VolatileData类中的两个方法，进行取值和自增操作
  */
  @Override
  public void run() {
    int oldValue = volatileData.getCounter();
    System.out.println("[Thread " + Thread.currentThread().getId() + "]: Old value = " + oldValue);
    volatileData.increaseCounter();
    int newValue = volatileData.getCounter();
    System.out.println("[Thread " + Thread.currentThread().getId() + "]: New value = " + newValue);
  }
 }

Erstellen Sie abschließend die VolatileMain-Klasse, um das obige Programm zu testen folgt:

public class VolatileMain {

  private final static int TOTAL_THREADS = 2;

  public static void main(String[] args) throws InterruptedException {
    VolatileData volatileData = new VolatileData();

    Thread[] threads = new Thread[TOTAL_THREADS];
    for(int i = 0; i < TOTAL_THREADS; ++i)
      threads[i] = new VolatileThread(volatileData);

    //开始读取变量值的操作
    for(int i = 0; i < TOTAL_THREADS; ++i)
      threads[i].start();

    //等待所有线程操作终止
    for(int i = 0; i < TOTAL_THREADS; ++i)
      threads[i].join();
  }
}

In der VolatileMain-Klasse werden zwei Threads verwendet, um auf flüchtige Variablen zuzugreifen. Die Ausgabe lautet wie folgt:

[Thread 10]: Old value = 0
[Thread 11]: Old value = 0
[Thread 10]: New value = 1
[Thread 11]: New value = 2

Wie Sie der Ausgabe entnehmen können, geben beide Threads zunächst den gleichen Wert aus, und nachdem die Methode raiseCounter aufgerufen wurde, greifen beide Threads auf den neuesten Wert der flüchtigen Variablen zu und geben ihn aus.

Passiert-vorher-Beziehung

Wenn ich das Schlüsselwort volatile verwende, muss ich die Passiert-vorher-Beziehung des Java-Speichermodells erwähnen. Die Geschehen-Vorher-Beziehung ist ein wichtiger Aspekt des Java-Speichermodells. Es wird zwischen zwei verschiedenen Ereignissen aufgebaut, sodass alle Änderungen am Objekt durch das erste Ereignis vom zweiten Ereignis sichtbar und widergespiegelt werden können. Wenn beispielsweise ein Thread in eine flüchtige Variable schreibt und ein anderer Thread anschließend auf die Variable zugreift, wird eine „Passiert vor“-Beziehung hergestellt. Daher sind alle Änderungen an flüchtigen Variablen für andere Threads sichtbar.

Dinge, die es zu beachten gilt

Bei der Verwendung des Schlüsselworts volatile in einem Programm müssen wir auf folgende Punkte achten:

1. Das Schlüsselwort volatile macht synchronisierte Operationen zwischen Atomen nicht überflüssig, da Speicherkonsistenzfehler weiterhin möglich sind.

2. Die Verwendung atomarer Variablen ist effizienter als die Verwendung synchronisierten synchronisierten Codes, aber in der Reihenfolge Vermeidung Speicherkonsistenzfehler erfordern zusätzlichen Aufwand

3. Das Schlüsselwort volatile kann synchronisierte synchronisierte Codeblöcke und Methoden nicht ersetzen

Das obige ist der detaillierte Inhalt vonDie Verwendung und Vorsichtsmaßnahmen des Schlüsselworts volatile in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!