Heim > Java > javaLernprogramm > Hauptteil

Nutzungsanalyse von flüchtigem und synchronisiertem Java-Multithreading

高洛峰
Freigeben: 2017-01-05 16:02:51
Original
1787 Leute haben es durchsucht

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);
    }
}
Nach dem Login kopieren

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 dem Login kopieren

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);
    }
}
Nach dem Login kopieren
package com.chzhao;
public class LockClass {
    public static byte[] lock = new byte[0];
}
Nach dem Login kopieren

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!


Verwandte Etiketten:
Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage