Wann wird java-thread-cache aktualisieren passiert?

Dies ist beschrieben in der JLS unter dem Abschnitt Threads und Locks.

Wenn Sie den thread Lesen aus dem Arbeitsspeicher ist definiert in Bezug auf die Synchronisation Ordnung und geschieht, bevor Sie bestellen. Im Grunde es sagt, dass, um für eine Lesen ergeben den Wert, der zuletzt geschrieben, der schreiben muss passieren-vor das zu Lesen.

Das passiert-vor relation ist grob definiert in Bezug auf sperren/entsperren Aktionen und (mit wenigen Ausnahmen) darauf an, die Nutzung von synchronized Methoden und-Blöcke. Es sei denn, Sie beschäftigen sich mit der volatile-Variablen, die bottom-line ist in der Regel, dass Sie brauchen, um synchronisieren Sie alle Zugriff auf gemeinsame Daten, vorzugsweise durch AtomicBoolean eine BlockingQueue oder anderen java.util.Auger-Klasse.

17.4.4 Synchronisierung, Um

Jede Ausführung hat eine Synchronisation um. Eine Synchronisation Ordnung ist eine totale Ordnung über alle die Synchronisierung der Aktionen, die einer Hinrichtung. Für jeden thread t, der Synchronisation, um die Synchronisation Maßnahmen (§17.4.2) in t ist im Einklang mit dem Programm-Auftrag (§17.4.3) von t.

Synchronisierung Aktionen induzieren die synchronisiert-mit Bezug auf Aktionen, die wie folgt definiert sind:

• Eine unlock-Aktion auf dem monitor m synchronisiert-mit allen nachfolgenden lock-Aktionen auf m (wo anschließend wird definiert, nach der Synchronisation Reihenfolge).
• Ein schreiben auf eine volatile-variable (§8.3.1.4) v synchronisiert-mit allen nachfolgenden Lesevorgänge in v von jedem thread (wo anschließend wird definiert, nach der Synchronisation Reihenfolge).
• Eine Aktion, die einen thread startet synchronisiert-mit der ersten Aktion in die Threads, die er startet.
• Dem schreiben des default-Wert (null, false oder null) für jede variable synchronisiert-mit der ersten Aktion in jedem thread. Obwohl es scheinen mag ein wenig seltsam zu schreiben, einen default-Wert zu einer Variablen, bevor das Objekt mit der Variablen zugeordnet ist, ist konzeptionell zu jedem Objekt erstellt beim start des Programms mit der Standardeinstellung initialisiert Werte.
• Die Letzte Aktion in einem thread T1 synchronisiert-mit jeder Aktion in einem anderen thread T2, dass erkennt, dass T1 beendet hat. T2 kann dies erreichen, indem Sie den Aufruf T1.isAlive() oder T1.join().
• Wenn thread T1 unterbricht thread T2, dass der interrupt von T1 synchronisiert-mit jedem Punkt, wo einem anderen thread (einschließlich T2) bestimmt, dass T2 unterbrochen wurde (durch eine InterruptedException geworfen oder durch aufrufen von Thread.unterbrochen oder Thread.isInterrupted).

Die Quelle synchronisiert-mit Rand wird als eine Version, und das Ziel heißt, eine zu erwerben.

17.4.5 Passiert-vor der Bestellung

Beiden Aktionen bestellt werden können durch eine happens-before Beziehung. Wenn eine Aktion passiert-bevor es ein anderer, dann die erste sichtbar ist und bestellt, bevor die zweite.

Wenn wir zwei Aktionen x und y, schreiben wir hb(x, y) zu zeigen, dass x passiert-vor y.

• Wenn x und y sind Aktionen, die von den gleichen Faden und kommt x vor y in das Programm um, dann hb(x, y).
• Es ist passiert-vor der Kante vom Ende der Konstruktor der ein Objekt um den start-ein finalizer (§12.6) für das Objekt.
• Wenn eine Aktion x synchronisiert-mit eine folgende Aktion y, dann haben wir auch hb(x, y).
• Wenn hb(x, y), und hb(y, z), dann hb(x, z).

Es sollte angemerkt werden, dass die Anwesenheit einer happens-before Beziehung zwischen zwei Handlungen impliziert nicht unbedingt, dass Sie stattfinden, in dieser Reihenfolge in eine Implementierung. Wenn die Neuordnung produziert Ergebnisse im Einklang mit einer rechtlichen Ausführung, ist es nicht illegal.

Update: Wenn nicht passiert-vor relation besteht, der thread ist nie erforderlich, um "refresh cache". Diese Frage und es angenommen wird, ist die Antwort liefert ein konkretes Beispiel dafür.

Hier ist eine leicht modifizierte version der akzeptierten Antwort:

public class Test {

    static boolean keepRunning = true;

    public static void main(String[] args) throws InterruptedException {

        (new Thread() {
            public void run() {
                while (keepRunning) {
                }
            }
        }).start();

        System.out.println(keepRunning);
        Thread.sleep(1000);
        keepRunning = false;
        System.out.println(keepRunning);

        //main thread ends here, but the while-thread keeps running.
        //(but not if you change the keepRunning to volatile).
    }
}

Ich weiß, das ist zu spät, um hinzufügen, um die gut erklärte Antwort. Aber ich hoffe, dass jemand bekommt Hilfe von meiner Antwort.Die Frage lautete, Wann wird java/jvm-Threads cache-refresh passiert?.

Gibt es keine Möglichkeit, die jvm wird flush oder aktualisieren Sie den lokalen thread-cache wenn Threads im Zustand runnable. Aber in Fällen wie beim thread ändern Sie seinen Zustand von selbst oder von externen thread-scheduler, dann auf jeden Fall den lokalen thread-cache-flush in den Hauptspeicher. Hier habe ich nur gezwickt das Beispiel aus der Antwort

    (new Thread() {
        public void run() {
            while (keepRunning) {
                LockSupport.parkUntil(500);
            }
        }
    }).start();

    System.out.println(keepRunning);
    Thread.sleep(1000);
    keepRunning = false;
    System.out.println(keepRunning);

Ich jetzt hier einfach die aktuellen in die wartenden thread. Diese Methode wird von vielen java-built-in-thread-Pools executor-wie üblich-thread-pool. So hier thread readfrom Arbeitsspeicher und beendet sich selbst.