Das volatile Schlüsselwort spielt eine relativ wichtige Rolle bei Java Multi-Threading. Die Hauptfunktion von Flüchtigkeit besteht darin, Variablen im Multi-Threading sichtbar zu halten, und ist der leichteste Synchronisationsmechanismus, der in Java bereitgestellt wird.
Sichtweite
Alle Variablen im Speichermodell von Java (die Variablen hier sind globale Variablen, keine lokalen Variablen. Es gibt kein Problem mit Thread-sicher in der Methode, da Variablen zerstört werden, wenn die Methode aufgerufen wird) im Hauptspeicher gespeichert werden. Jeder Thread hat seinen eigenen Arbeitsgedächtnis. Jedes Mal, wenn der Thread ausgeführt wird, wird eine Kopie der Variablen aus dem Hauptspeicher erhalten, und der Betrieb der Variablen wird im Arbeitsspeicher des Threads durchgeführt. Verschiedene Threads können das Arbeitsspeicher nicht freigeben und können nur die Kopie der Variablen aus dem Hauptspeicher lesen. Insbesondere kann es in der folgenden Abbildung ausgedrückt werden:
Für volatile (unter Verwendung von synchronisierten/endgültigen Modifikationen ist die obige Regel unterbrochen, dh wenn der Thread den Wert der Variablen verändert, können andere Threads sofort die Änderung der Variablen kennen. Für gewöhnliche Variablen jedoch, wenn ein Thread eine Variable verändert, ist es notwendig, die Variable zurück zu schreiben. Zuerst. kann abgeleitet werden, dass eine Variable, die durch volatile modifiziert ist, garantiert ist, dass die Variable in einer Multi-Thread-Umgebung sicher ist, da sie für den Arbeitsgedächtnis aller Threads sichtbar ist.
public class test {private statische volatile t = 0; private static int add () {return t ++; } public static void testvolatile () {für (int i = 0; i <20; i ++) {Thread = neuer Thread (()-> {für (int j = 0; j <1000; j ++) {add ();}}); Thread.Start (); } while (thread.activeCount ()> 1) {thread.yield (); } System.out.println (t); } public static void main (String [] args) {TestVolatile (); }}Es wird erwartet, dass der T -Wert 20.000 betragen sollte, aber es wird eine Situation geben, in der der T -Wert weniger als 20.000 beträgt. Sie sollten den Grund erraten. Das Problem liegt in T ++. T ++ ist keine Atomoperation. In Java bedeutet die T ++ - Operation zuerst, um den T -Wert zu erhalten, dann 1 hinzuzufügen und dann t zuzuweisen. Bei der Erlangung des T -Werts wird er durch flüchtiges modifiziert, sodass der neueste Wert des Threads erhalten werden kann. Beim Hinzufügen von 1 kann es jedoch nicht garantiert werden. Es ist möglich, dass andere Threads bereits 1 hinzugefügt haben.
Welches Szenario ist also am besten geeignet, um volatil zu verwenden?
* Im variablen Betrieb hängt nicht vom aktuellen Wert ab
* Variablen müssen nicht an invarianten Einschränkungen mit anderen staatlichen Variablen teilnehmen
In Chinese übersetzt bedeutet, dass Sie für Variablen, die sowohl gelesen als auch in Multi-Threads geschrieben haben, volatil verwenden können, um sie zu ändern. Auf diese Weise sollten Sie keine Sperr-/synchronisierten Vorgänge für Lesevorgänge verwenden. Direktes Lesen liegt daran, dass Variablen sichtbar sind.