Ich glaube, dass Leser, die Java-Multithreading verstehen, seine Rolle klar kennen werden. Das Schlüsselwort volatile wird zum Deklarieren einfacher Typvariablen wie int, float, boolean und anderer Datentypen verwendet. Wenn diese einfachen Datentypen als flüchtig deklariert werden, werden Operationen auf ihnen atomar. Dies hat jedoch gewisse Einschränkungen. Beispielsweise ist n im folgenden Beispiel nicht atomar:
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Die öffentliche Klasse JoinThread erweitert Thread
{
öffentliches statisches flüchtiges int n = 0;
public void run()
{
for (int i = 0; i < 10; i++)
versuchen
{
n = n + 1;
sleep(3); // Um die laufenden Ergebnisse zufälliger zu machen, verzögern Sie 3 Millisekunden
}
Catch (Ausnahme e)
{
}
}
public static void main(String[] args) löst eine Ausnahme aus
{
Thread-Threads[] = neuer Thread[100];
for (int i = 0; i < threads.length; i++)
// 100 Threads erstellen
threads[i] = new JoinThread();
for (int i = 0; i < threads.length; i++)
//Die gerade erstellten 100 Threads ausführen
threads[i].start();
for (int i = 0; i < threads.length; i++)
//Fortfahren, nachdem alle 100 Threads ausgeführt wurden
threads[i].join();
System.out.println("n=" + JoinThread.n);
}
}
Wenn die Operation für n atomar ist, sollte das endgültige Ausgabeergebnis n = 1000 sein. Bei der Ausführung des obigen Vorwahlcodes ist die Ausgabe n jedoch häufig kleiner als 1000, was zeigt, dass n = n + 1 keine Operation auf atomarer Ebene ist . . Der Grund dafür ist, dass bei einer einfachen, als flüchtig deklarierten Variablen der aktuelle Wert mit dem vorherigen Wert der Variablen in Beziehung steht und das Schlüsselwort volatile keine Wirkung hat. Dies bedeutet, dass die folgenden Ausdrücke keine atomaren Operationen sind:
Kopieren Sie den Codecode wie folgt:
n = n + 1;
n++;
Wenn Sie diese Situation zu einer atomaren Operation machen möchten, müssen Sie das synchronisierte Schlüsselwort verwenden. Der obige Code kann in die folgende Form geändert werden:
Kopieren Sie den Codecode wie folgt:
Paket mythread;
Die öffentliche Klasse JoinThread erweitert Thread
{
öffentliches statisches int n = 0;
öffentliches statisches synchronisiertes void inc()
{
n++;
}
public void run()
{
for (int i = 0; i < 10; i++)
versuchen
{
inc(); // n = n + 1 geändert in inc();
sleep(3); // Um die laufenden Ergebnisse zufälliger zu machen, verzögern Sie 3 Millisekunden
}
Catch (Ausnahme e)
{
}
}
public static void main(String[] args) löst eine Ausnahme aus
{
Thread-Threads[] = neuer Thread[100];
for (int i = 0; i < threads.length; i++)
// 100 Threads erstellen
threads[i] = new JoinThread();
for (int i = 0; i < threads.length; i++)
//Die gerade erstellten 100 Threads ausführen
threads[i].start();
for (int i = 0; i < threads.length; i++)
//Fortfahren, nachdem alle 100 Threads ausgeführt wurden
threads[i].join();
System.out.println("n=" + JoinThread.n);
}
}
Der obige Code ändert n=n+1 in inc(), wobei die inc-Methode das synchronisierte Schlüsselwort für die Methodensynchronisierung verwendet. Seien Sie daher vorsichtig, wenn Sie das Schlüsselwort volatile verwenden. Dies bedeutet nicht, dass alle Operationen an dieser Variablen die ursprünglichen Operationen sind, die durch ihren vorherigen bestimmt werden n+1, n++ usw., das Schlüsselwort volatile ist nur dann ungültig, wenn der Wert der Variablen nichts mit ihrem vorherigen Wert zu tun hat ist das ursprüngliche Niveau. Daher müssen Sie bei der Verwendung flüchtiger Schlüssel vorsichtig sein. Wenn Sie sich nicht sicher sind, können Sie synchronisierte anstelle von flüchtigen Schlüsseln verwenden.