Nutzungsanalyse von flüchtigem und synchronisiertem Java-Multithreading

In diesem Artikel wird die Verwendung von Volatile und Synchronized im Java-Multithreading anhand von Beispielen analysiert. Teilen Sie es als Referenz mit allen. Die spezifische Implementierungsmethode lautet wie folgt:

package com.chzhao;
public class Volatiletest extends Thread {
    private static int count = 0;
    public void run() {
        count++;
    }
    public static void main(String[] args) {
        Thread threads[] = new 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();
        }
        try {
            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++ nicht threadsicher ist, beträgt die Ausgabe häufig weniger als 10000.

Um dieses Problem zu lösen, wurde das Schlüsselwort volatile hinzugefügt.

package com.chzhao;
public class Volatiletest extends Thread {
    private volatile static int count = 0;
    public void run() {
        count++;
    }
    public static void main(String[] args) {
        Thread threads[] = new 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();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

Nach der Änderung werden häufig andere Werte als 10000 ausgegeben.

wird in eine synchronisierte Form geändert, der Code lautet wie folgt:

package com.chzhao;
public class SynchronizedTest extends Thread {
    private static int count = 0;
    public void run() {
        synchronized (LockClass.lock) {
            count++;
        }
    }
    public static void main(String[] args) {
        Thread threads[] = new 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();
        }
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(count);
    }
}

package com.chzhao;
public class LockClass {
    public static byte[] lock = new byte[0];
}

Nach dieser Änderung ist die Ausgabe 10000.

Bedeutet dies, dass die Ist das flüchtige Stichwort völlig nutzlos? Kann nur die Synchronisierung die Thread-Sicherheit gewährleisten?

Hinweis:

Die Java-Sprache enthält zwei intrinsische 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“ angesehen 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. Natürlich ist die Synchronisierung schlechter.

Ich hoffe, dass dieser Artikel für alle bei der Java-Programmierung hilfreich sein wird.

Weitere Artikel zur Nutzungsanalyse von flüchtigem und synchronisiertem Java-Multithreading finden Sie auf der chinesischen PHP-Website!