Wofür ist das Schlüsselwort volatile nützlich?

Question

Bei der Arbeit stieß ich heute auf die volatile Schlüsselwort in Java. Da ich damit nicht sehr vertraut bin, fand ich diese Erklärung .

Wenn man bedenkt, wie detailliert in diesem Artikel das betreffende Schlüsselwort erklärt wird, haben Sie es dann jemals verwendet oder könnten Sie sich einen Fall vorstellen, in dem Sie dieses Schlüsselwort auf die richtige Art und Weise verwenden könnten?

Answer 1

volatile hat eine Semantik für Speichersichtbarkeit. Grundsätzlich ist der Wert einer volatile Feld wird für alle Leser (insbesondere für andere Threads) sichtbar, nachdem ein Schreibvorgang darauf abgeschlossen wurde. Ohne volatile könnten die Leser einen nicht aktualisierten Wert sehen.

Um Ihre Frage zu beantworten: Ja, ich verwende ein volatile um zu steuern, ob ein Code eine Schleife fortsetzt. Die Schleife testet die volatile Wert und fährt fort, wenn er true . Die Bedingung kann eingestellt werden auf false durch den Aufruf einer "Stop"-Methode. Die Schleife sieht false und bricht ab, wenn es den Wert nach Beendigung der Ausführung der Stop-Methode testet.

Das Buch " Java-Gleichzeitigkeit in der Praxis ", das ich sehr empfehle, gibt eine gute Erklärung der volatile . Dieses Buch wurde von der gleichen Person geschrieben, die auch den IBM-Artikel verfasst hat, auf den in der Frage Bezug genommen wird (er zitiert sein Buch sogar am Ende des Artikels). Meine Verwendung von volatile ist das, was in seinem Artikel als "Muster-1-Statusflagge" bezeichnet wird.

Wenn Sie mehr darüber erfahren möchten, wie volatile unter der Haube funktioniert, lesen Sie mehr über das Java-Speichermodell . Wenn Sie über dieses Niveau hinausgehen wollen, lesen Sie ein gutes Buch über Computerarchitektur wie Hennessy & Patterson und lesen Sie über Cache-Kohärenz und Cache-Konsistenz.

Answer 2

" der flüchtige Modifikator garantiert, dass jeder Thread, der ein Feld liest, den zuletzt geschriebenen Wert sieht." - Josh Bloch

Wenn Sie darüber nachdenken, Folgendes zu verwenden volatile lesen Sie auf der Verpackung nach java.util.concurrent die sich mit atomarem Verhalten befasst.

Der Wikipedia-Beitrag über eine Singleton-Muster zeigt flüchtig im Einsatz.

Answer 3

Flüchtig (vltl): Leicht verdunstend bei normalen Temperaturen

Wichtiger Punkt über volatile :

1. Die Synchronisierung in Java ist durch die Verwendung von Java-Schlüsselwörtern möglich synchronized et volatile und Schlösser.
2. In Java können wir nicht haben synchronized variabel. Verwendung von synchronized Schlüsselwort mit einer Variablen ist illegal und führt zu einem Kompilierungsfehler. Anstelle der Verwendung des synchronized Variable in Java zu verwenden, können Sie die java volatile Variable, die JVM-Threads anweist, den Wert von volatile Variable aus dem Hauptspeicher und speichern Sie sie nicht lokal zwischen.
3. Wenn eine Variable nicht von mehreren Threads gemeinsam genutzt wird, ist es nicht notwendig, die volatile Stichwort.

Quelle

Beispiel für die Verwendung von volatile :

public class Singleton {
    private static volatile Singleton _instance; // volatile variable
    public static Singleton getInstance() {
        if (_instance == null) {
            synchronized (Singleton.class) {
                if (_instance == null)
                    _instance = new Singleton();
            }
        }
        return _instance;
    }
}

Wir erstellen die Instanz erst dann, wenn die erste Anfrage kommt.

Wenn wir nicht die _instance variabel volatile dann wird der Thread, der die Instanz von Singleton ist nicht in der Lage, mit dem anderen Thread zu kommunizieren. Wenn also Thread A eine Singleton-Instanz erstellt und kurz nach der Erstellung die CPU beschädigt wird usw., können alle anderen Threads den Wert von _instance als nicht null, und sie werden glauben, dass es immer noch als null zugewiesen wird.

Warum ist das so? Weil Leser-Threads nicht sperren und bis der Schreiber-Thread aus einem synchronisierten Block herauskommt, wird der Speicher nicht synchronisiert und der Wert von _instance wird nicht im Hauptspeicher aktualisiert. Mit dem Schlüsselwort Volatile in Java wird dies von Java selbst gehandhabt, und solche Aktualisierungen sind für alle Leser-Threads sichtbar.

Schlussfolgerung : volatile Schlüsselwort wird auch verwendet, um den Inhalt des Speichers zwischen Threads zu kommunizieren.

Beispiel für die Verwendung von ohne flüchtig:

public class Singleton{    
    private static Singleton _instance;   //without volatile variable
    public static Singleton getInstance(){   
          if(_instance == null){  
              synchronized(Singleton.class){  
               if(_instance == null) _instance = new Singleton(); 
      } 
     }   
    return _instance;  
    }

Der obige Code ist nicht thread-sicher. Obwohl er den Wert der Instanz innerhalb des synchronisierten Blocks noch einmal überprüft (aus Leistungsgründen), kann der JIT-Compiler den Bytecode so umstellen, dass der Verweis auf die Instanz gesetzt wird, bevor der Konstruktor seine Ausführung beendet hat. Das bedeutet, dass die Methode getInstance() ein Objekt zurückgibt, das möglicherweise nicht vollständig initialisiert wurde. Um den Code thread-sicher zu machen, kann seit Java 5 das Schlüsselwort volatile für die Instanzvariable verwendet werden. Variablen, die als flüchtig gekennzeichnet sind, werden für andere Threads erst sichtbar, wenn der Konstruktor des Objekts seine Ausführung vollständig beendet hat.
Quelle

volatile Verwendung in Java :

Die ausfallsicheren Iteratoren sind typischerweise implementiert mit einer volatile Zähler auf dem Listenobjekt.

• Wenn die Liste aktualisiert wird, wird der Zähler erhöht.
• Wenn ein Iterator erstellt wird, wird der aktuelle Wert des Zählers in die Iterator Objekt.
• Wenn ein Iterator Operation durchgeführt wird, vergleicht die Methode die beiden Zählerwerte und löst einen ConcurrentModificationException wenn sie unterschiedlich sind.

Die Implementierung von ausfallsicheren Iteratoren ist in der Regel leichtgewichtig. Sie beruhen in der Regel auf den Eigenschaften der Datenstrukturen der jeweiligen Listenimplementierung. Es gibt kein allgemeines Muster.

Answer 4

volatile ist sehr nützlich, um Threads anzuhalten.

Nicht, dass Sie Ihre eigenen Threads schreiben sollten, Java 1.6 hat eine Menge schöner Thread-Pools. Aber wenn Sie sicher sind, dass Sie einen Thread brauchen, müssen Sie wissen, wie Sie ihn anhalten können.

Das Muster, das ich für die Fäden verwende, lautet:

public class Foo extends Thread {

  private volatile boolean close = false;

  public void run() {
    while(!close) {
      // do work
    }
  }
  public void close() {
    close = true;
    // interrupt here if needed
  }
}

In dem obigen Codesegment liest der Thread close in der while-Schleife unterscheidet sich von derjenigen, die close() . Ohne Volatile sieht der Thread, der die Schleife ausführt, möglicherweise nie die Änderung zum Schließen.

Beachten Sie, dass eine Synchronisierung nicht erforderlich ist.

Answer 5

Eine Variable, die mit volatile hat zwei wesentliche Eigenschaften, die es zu etwas Besonderem machen.

1. Wenn wir eine flüchtige Variable haben, kann sie von keinem Thread im Cache-Speicher des Computers (Mikroprozessors) zwischengespeichert werden. Der Zugriff erfolgt immer vom Hauptspeicher aus.

2. Wenn es eine Schreibvorgang auf eine flüchtige Variable, und plötzlich wird eine Lesevorgang angefordert wird, ist gewährleistet, dass die der Schreibvorgang wird vor dem Lesevorgang abgeschlossen .

Aus den beiden oben genannten Eigenschaften ergibt sich, dass

• Alle Threads, die eine flüchtige Variable lesen, werden definitiv den letzten Wert lesen. Denn kein zwischengespeicherter Wert kann ihn verunreinigen. Und auch die Leseanforderung wird erst nach Abschluss des aktuellen Schreibvorgangs gewährt.

Und auf der anderen Seite,

• Wenn wir das Thema weiter untersuchen #2 die ich erwähnt habe, können wir sehen, dass volatile ist ein idealer Weg, um eine gemeinsame Variable zu pflegen, die 'n' Anzahl von Leser-Threads und nur ein Schreiber-Thread um darauf zuzugreifen. Sobald wir die volatile Schlüsselwort, ist es erledigt. Kein weiterer Overhead über die Threadsicherheit.

Konversation,

Wir kann nicht ausnutzen volatile Schlüsselwort, um eine gemeinsame Variable zu erfüllen, die mehr als ein Writer-Thread darauf zugreift .