Dieser Artikel analysiert die Verwendung von flüchtigem und synchronisiertem Multithreading in Java anhand von Beispielen. Teilen Sie es als Referenz mit allen. Die spezifische Implementierungsmethode ist wie folgt:
Kopieren Sie den Code wie folgt: package com.chzhao;
öffentliche Klasse Volatiletest erweitert Thread {
private static int count = 0;
public void run() {
count++;
}
public static void main(String[] args) {
Thread-Threads[] = neuer Thread[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Volatiletest();
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
versuchen {
Thread.sleep(1000);
} Catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
}
}
Der Code ist wie oben. Die erwartete Ausgabe beträgt 10000. Da count++ jedoch nicht threadsicher ist, liegt die Ausgabe häufig unter 10000.
Um dieses Problem zu lösen, wurde das Schlüsselwort volatile hinzugefügt.
Kopieren Sie den Code wie folgt: package com.chzhao;
öffentliche Klasse Volatiletest erweitert Thread {
private volatile static int count = 0;
public void run() {
count++;
}
public static void main(String[] args) {
Thread-Threads[] = neuer Thread[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Volatiletest();
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
versuchen {
Thread.sleep(2000);
} Catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
}
}
Nach der Änderung werden häufig andere Werte als 10000 ausgegeben.
Ändern Sie es in eine synchronisierte Form. Der Code lautet wie folgt:
Kopieren Sie den Code wie folgt: package com.chzhao;
öffentliche Klasse SynchronizedTest erweitert Thread {
private static int count = 0;
public void run() {
synchronisiert (LockClass.lock) {
count++;
}
}
public static void main(String[] args) {
Thread-Threads[] = neuer Thread[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new SynchronizedTest();
}
for (int i = 0; i < threads.length; i++) {
threads[i].start();
}
versuchen {
Thread.sleep(2000);
} Catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(count);
}
}
Kopieren Sie den Code wie folgt: package com.chzhao;
öffentliche Klasse LockClass {
öffentliches statisches Byte[] lock = neues Byte[0];
}
Nach dieser Änderung beträgt die Ausgabe 10000.
Bedeutet das, dass das Schlüsselwort volatile völlig nutzlos ist? Nur synchronisiert kann Thread-Sicherheit gewährleistet werden?
veranschaulichen:
Die Java-Sprache enthält zwei inhärente Synchronisationsmechanismen: synchronisierte Blöcke (oder Methoden) und flüchtige Variablen. Beide Mechanismen werden vorgeschlagen, um Code-Thread-Sicherheit zu erreichen. Flüchtige Variablen sind weniger synchronisiert (aber manchmal einfacher und kostengünstiger) und ihre Verwendung ist auch fehleranfälliger. Flüchtige Variablen in der Java-Sprache können als „weniger synchronisiert“ betrachtet werden. Im Vergleich zu synchronisierten Blöcken erfordern flüchtige Variablen weniger Codierung und haben einen geringeren Laufzeitaufwand, können jedoch nur einen Teil der synchronisierten Funktionalität erreichen.
Mit anderen Worten: In manchen Fällen ist volitile bequemer zu verwenden als synchronisiert, aber natürlich ist die Synchronisierung schlechter.
Ich hoffe, dass dieser Artikel für die Java-Programmierung aller hilfreich sein wird.