Das code-Beispiel, die sich als "volatile" deklarieren sollte verwendet werden

Derzeit kann ich nicht verstehen, wenn wir volatile zum deklarieren von Variablen.

Ich habe zu tun einige Studie und suchte einige Materialien über die für eine lange Zeit und weiß, dass, wenn ein Feld deklariert ist flüchtig, der compiler und die Laufzeit werden auf beachten Sie, dass diese variable geteilt wird, und dass Operationen sollten nicht nachbestellt werden mit anderen Speicher-Operationen.

Aber ich kann immer noch nicht verstehen, in welches Szenario wir sollten Sie nutzen. Ich meine, kann jemand irgendwelche Beispiel-code, die nachweisen können, dass die Verwendung von "volatile" - bringt nutzen oder Probleme zu lösen, zu vergleichen, um ohne es zu benutzen?

volatile (und viele andere concurrency-Aspekte) sind sehr schwer zu beweisen, denn wenn du diese falsch, dann kann Sie immer noch erscheinen, um korrekt zu arbeiten und nicht ein problem, bis zu einer ganz bestimmten Bedingung Auftritt, und führt zu einem problem.
Ich habe versucht, diese selbst und produziert eine Prüfung, die übergabe von Werten zwischen Gewinde mit einem nicht-voltile Feld eine Milliarde mal erfolgreich, jedoch schlägt relativ schnell, wenn es die gleiche box ist geladen. Auch das timing der performance-Auswirkungen flüchtiger wird sehr schwierig werden, es hängt von vielen Faktoren ab.
Haben Sie einen Blick auf diese post: stackoverflow.com/questions/7855700/...

InformationsquelleAutor Eric Jiang | 2011-04-28

15

Hier ist ein Beispiel, warum volatile notwendig ist. Wenn Sie entfernen Sie das Schlüsselwort volatile thread 1 kann nie kündigen. (Wenn ich getestet auf Java 1.6 Hotspot auf Linux, dies war in der Tat der Fall ist - Ihre Ergebnisse können variieren, da die JVM ist nicht verpflichtet, zu tun, keine Zwischenspeicherung von Variablen, die nicht markiert volatile.)
```
public class ThreadTest {
  volatile boolean running = true;

  public void test() {
    new Thread(new Runnable() {
      public void run() {
        int counter = 0;
        while (running) {
          counter++;
        }
        System.out.println("Thread 1 finished. Counted up to " + counter);
      }
    }).start();
    new Thread(new Runnable() {
      public void run() {
        //Sleep for a bit so that thread 1 has a chance to start
        try {
          Thread.sleep(100);
        } catch (InterruptedException ignored) { 
         //catch block
        }
        System.out.println("Thread 2 finishing");
        running = false;
      }
    }).start();
  }

  public static void main(String[] args) {
    new ThreadTest().test();
  }
}
```
- Sorry, ich habe versucht, zu entfernen "volatile" - Schlüsselworts und führen Sie das Programm, für das viele Male, aber jedes mal, wenn thread 1 beendet werden kann. Ich denke für den code, den Sie auch ohne "volatile" - thread 1 kann immer gekündigt werden, jedes mal.
- gibt es den Effekt, beschreibe ich auf zwei verschiedenen Rechnern läuft Java 6 JVM. Ich denke, ich sollte so formuliert es anders. Es ist nur garantiert kündigen, wenn der volatile-Schlüsselwort vorhanden ist. Wenn es nicht vorhanden ist, die JVM ist frei, cache den Wert running, also thread 1 müssen nicht kündigen. Es ist jedoch nicht gezwungen, cache den Wert.
- Halten Sie "flüchtig" präsentieren wird beendet-thread 1 so bald als 'running' gesetzt false im thread 2. Aber, wenn Sie "flüchtig", thread 1 kann nicht kündigen, auch nach 'läuft' wird gesetzt false in Thread2 verzahnt, wenn der thread beendet wird hängt davon ab, Wann die JVM-update "laufen" - Wert in thread 1. Meinst du das??? Aber wenn "running" gesetzt wurde, 'false' in thread 2, warum thread1 kann nicht den richtigen Wert??? Wenn ja, ich denke, die JVM-Verhalten sich falsch.
- Die JVM ist nicht falsch Verhalten. Ohne volatile (oder Synchronisation, oder etwas anderes welche Kräfte ein "passiert-vor" - Beziehung), thread 1 müssen nicht sehen, die änderung, die von thread 2.
- das ist genau das problem: "korrekte Verhalten" ist nicht äquivalent zu "intuitiv handeln". JVMs kostenlos-cache-Werte (zum Beispiel in das register einer CPU), wenn es gelesen wird, immer wieder und brauchen es nicht Lesen aus Hauptspeicher und das jedes mal. Die Angabe einer variable volatile deaktiviert das caching!
- Nickerson: vielen Dank für Ihre Hilfe. Wie etwa in diesem Beispiel: class TestThread extends Thread { private boolean running = true; public void run() { while(running) { //do something } } public void setStop() { running = false; } } Die Methode 'setStop' wird aufgerufen in einem anderen thread, die Sie aufhalten will 'TestThread'. Damit ich hier nicht daneben läuft, wie flüchtig, so gibt es eine chance, dass TestThread nicht sofort angehalten (vielleicht sogar nie aufhört) nach setStop() aufgerufen wird, in einem anderen thread, richtig? Hier der sichere Weg ist, die ich brauche zu markieren, ausgeführt als flüchtige, richtig?
- ja, das ist richtig
- Dank Simon! Sie haben mir sehr geholfen.
InformationsquelleAutor Simon Nickerson
4

Folgende ist ein Paradebeispiel für die Notwendigkeit von flüchtigen (in diesem Fall für die str variable. Ohne hotspot-Aufzüge den Zugriff außerhalb der Schleife (while (str == null)) und run() nie beendet. Dies geschieht auf den meisten server JVMs.
```
public class DelayWrite implements Runnable {
  private String str;
  void setStr(String str) {this.str = str;}

  public void run() {
    while (str == null);
    System.out.println(str);
  }

  public static void main(String[] args) {
    DelayWrite delay = new DelayWrite();
    new Thread(delay).start();
    Thread.sleep(1000);
    delay.setStr("Hello world!!");
  }
}
```
- Wesley: ich Danke Ihnen sehr!!! Ich sehe das Problem mit den java -server zu starten der JVM und ausführen der app. Nun bekomme ich meine Antwort, vielen Dank!
- new Thread(Spaß).start(); diese Zeile sollte neuen Thread(Verzögerung).start(); korrekt ?
- Große und nützliche! Ich habe eine weitere Fragen 1) Wieso benutzt 'kanonische '? 2) Wie könnte ich den Assembler-code als der java-code ausgeführt wird? bekomme ich einige Ahnung von der Montage, wie bei anderen cpp-code-Demonstrationen?
InformationsquelleAutor Jed Wesley-Smith
3

Eric, ich habe Ihre Kommentare zu Lesen und vor allem fällt mir auf

In der Tat, ich kann verstehen, dass die Verwendung von flüchtigen auf das Konzept
Ebene. Aber für die Praxis, ich kann nicht denken
bis der code die Parallelität
Probleme ohne Verwendung von flüchtigen

Das offensichtliche problem, das Sie haben können, sind compiler-reorderings, zum Beispiel die berühmten hochziehen wie erwähnt von Simon Nickerson. Aber lassen Sie uns davon ausgehen, dass es keine reorderings, dieser Kommentar kann eine gültige ein.

Weiteres Problem, das flüchtige löst mit 64-bit-Variablen (long, double). Wenn Sie schreiben, um einen langen oder Doppel, es wird behandelt wie zwei getrennte 32-bit speichert. Was passieren kann, mit einer gleichzeitigen schreiben ist die hohe 32 von einem thread geschrieben wird, um hohen 32-bits des Registers, während ein anderer thread schreibt der niedrigen 32 bit. Sie können dann eine lange, das ist weder das eine noch das andere.

Auch, wenn man sich die Speicher-Abschnitt, der die JLS werden Sie beobachten, Sie werden eine entspannte Speicher-Modell.

Das bedeutet, dass Schreibvorgänge dürfen nicht sichtbar sein (können sitzen in einem Speicher-Puffer) für eine Weile. Dies kann dazu führen, veraltete liest. Jetzt können Sie sagen, dass scheint unwahrscheinlich, und es ist, aber dein Programm ist falsch und hat das Potenzial zu scheitern.

Wenn Sie ein int, das Sie Inkrementieren für die Lebensdauer einer Anwendung-und Sie wissen (oder zumindest denken) die int-nicht überlaufen-dann musst du nicht ein upgrade auf eine lange, aber es ist immer noch möglich, es können. Im Falle eines Speicher-Sichtbarkeit von Problem, wenn Sie denken, es sollte keinen Einfluss auf Sie, Sie sollten wissen, dass es immer noch können und können zu Fehlern führen, die in Ihrer gleichzeitigen Anwendung, die äußerst schwierig zu identifizieren. Richtigkeit ist der Grund für die Verwendung von volatile.

InformationsquelleAutor John Vint
2

Dem volatile-Schlüsselwort ist ziemlich Komplex und Sie brauchen, um zu verstehen, was es tut und nicht gut tun, bevor Sie es verwenden. Ich empfehle die Lektüre diese Sprache-Spezifikation Abschnitt, das erklärt es sehr gut.

Markieren Sie dieses Beispiel:
```
class Test {
    static volatile int i = 0, j = 0;
    static void one() { i++; j++; }
    static void two() {
        System.out.println("i=" + i + " j=" + j);
    }
}
```
Was dies bedeutet ist, dass während one() j ist nie größer als i. Jedoch einem anderen Thread ausgeführt two() vielleicht drucken Sie einen Wert von j die viel größer ist als i denn mal sagen two() läuft und holt sich den Wert von i. Dann one() läuft 1000 mal. Dann wird der Thread zwei bekommt endlich wieder geplant und nimmt j das ist jetzt viel größer als der Wert des i. Ich denke, dieses Beispiel perfekt zeigt den Unterschied zwischen volatile und synchronized - updates zu i und j sind flüchtig, was bedeutet, dass die Reihenfolge, in der Sie geschehen im Einklang mit dem source-code. Doch die beiden updates passieren separat und nicht atomar so dass Anrufer kann sehen, Werte, Aussehen (zum Anrufer) inkonsistent sein.

Kurz gesagt: Seien Sie sehr vorsichtig mit volatile!
- Aus dem link, den Sie bieten, ein Beispiel: class Test { static volatile int i = 0, j = 0; static void ein() { i++; j++; } static void zwei() { System.aus.println("i=" + i + " j=" + j); } } "auf Diese Weise ist eine Methode und die Methode zwei, um gleichzeitig ausgeführt werden, aber garantiert, dass Zugriffe auf die shared Werte für i und j auftreten, genau so, wie viele Male, und in genau der gleichen Reihenfolge, wie Sie erscheinen auftreten, während der Ausführung des Programms den text, indem jeder thread", Aber ich glaube nicht, dass das Beispiel richtig ist, mit "volatile" oder nicht hat das gleiche Ergebnis, j immer die chance hat, anders zu sein als ich.
- Jiang - Der Punkt j kann das größer als ich. Obwohl ich immer zuerst inkrementiert. Wenn beide flüchtig sind, können Sie immer noch anders sein, aber j kann nicht größer sein als ich.
- Ich aktualisiert meine Antwort zu erklären, was ich denke, die Justiz, Freiheit und Sicherheit ist zu sagen (obwohl ich denke, die Justiz, Freiheit und Sicherheit, sagte, dass es sehr gut in den ersten Platz) 🙂
- Dank alpian, in der Tat, ich kann, fangen Ihre Bedeutung sehr gut, aber wenn ich den code ausführen und testen Sie viele, viele Male, die ich nie sehen J ist größer als ich. Ist es in Bezug auf meine PC-Umgebung, wie z.B. JDK-version oder hardware? Kann ich verstehen, so dass auch der code ausgeführt wird, die für Hunderte, Tausende Male kann es eine Zeit, dass J größer ist als ich (hat nur ein Risiko, aber vielleicht nicht passieren wird, so müssen für die Verwendung von 'volatile' zu gewährleisten), richtig?
InformationsquelleAutor alpian

Ein minimalistisches Beispiel in java 8, wenn Sie entfernen volatile-Schlüsselwort, es wird nie enden.

public class VolatileExample {

    private static volatile boolean BOOL = true;

    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> { while (BOOL) { } }).start();
        TimeUnit.MILLISECONDS.sleep(500);
        BOOL = false;
    }
}

InformationsquelleAutor Arnaud

Erweitern auf die Antwort von @jed-wesley-smith, wenn Sie diese drop in ein neues Projekt, nehmen Sie die volatile Schlüsselwort aus der iterationCount, und führen Sie es, es wird nie aufhören. Hinzufügen das volatile-Schlüsselwort entweder str oder iterationCount würde dazu führen, den code zu Ende erfolgreich. Ich habe auch bemerkt, dass der Schlaf kann nicht kleiner sein als 5, die mit Java 8, aber vielleicht kann Ihre Laufleistung variieren mit anderen JVM /Java-Versionen.

public static class DelayWrite implements Runnable
{
    private String str;
    public volatile int iterationCount = 0;

    void setStr(String str)
    {
        this.str = str;
    }

    public void run()
    {
        while (str == null)
        {
            iterationCount++;
        }
        System.out.println(str + " after " + iterationCount + " iterations.");
    }
}

public static void main(String[] args) throws InterruptedException
{
    System.out.println("This should print 'Hello world!' and exit if str or iterationCount is volatile.");
    DelayWrite delay = new DelayWrite();
    new Thread(delay).start();
    Thread.sleep(5);
    System.out.println("Thread sleep gave the thread " + delay.iterationCount + " iterations.");
    delay.setStr("Hello world!!");
}

InformationsquelleAutor Aron

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.