Analyse de l'utilisation de volatile et synchronisé dans le multithreading Java

Cet article analyse l'utilisation de volatile et synchronisé dans le multi-threading Java avec des exemples. Partagez-le avec tout le monde pour votre référence. La méthode d'implémentation spécifique est la suivante :

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);
    }
}

Le code est comme ci-dessus. La sortie attendue est de 10 000. Ensuite, comme le nombre n'est pas thread-safe, la sortie sera souvent inférieure à 10 000.

Afin de résoudre ce problème, ajout d'un mot-clé volatile.

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);
    }
}

Après modification, des valeurs autres que 10000 sont souvent sorties.

est modifié en forme synchronisée, le code est le suivant :

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];
}

Après cette modification, la sortie est 10000.

Est-ce que cela signifie que le Le mot-clé volatile est complètement inutile ? Seule la synchronisation peut garantir la sécurité des threads ?

Remarque :

Le langage Java contient deux mécanismes de synchronisation intrinsèques : les blocs (ou méthodes) synchronisés et les variables volatiles. Les deux mécanismes sont proposés pour assurer la sécurité des threads de code. Les variables volatiles sont moins synchronisées (mais parfois plus simples et moins coûteuses), et leur utilisation est également plus sujette aux erreurs. Les variables volatiles dans le langage Java peuvent être considérées comme « moins synchronisées » ; par rapport aux blocs synchronisés, les variables volatiles nécessitent moins de codage et ont moins de temps d'exécution, mais ce qu'elles peuvent réaliser n'est qu'une partie de la synchronisation.

En d'autres termes, dans certains cas, volitile est plus pratique à utiliser que synchronisé, mais bien sûr, la synchronisation est pire.

J'espère que cet article sera utile à la programmation Java de chacun.

Pour plus d'articles liés à l'analyse de l'utilisation du multi-threading volatile et synchronisé en Java, veuillez faire attention au site Web PHP chinois !