Analyse du code du mot clé Java volatile

Le contenu de cet article concerne l'analyse du code du mot-clé Java volatile. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Je crois que la plupart des programmeurs Java ont appris à utiliser le mot-clé volatile. La définition de volatile sur l'Encyclopédie Baidu :

Volatile est un spécificateur de type conçu pour modifier les variables accessibles et modifiées par différents threads. volatile fonctionne comme un mot-clé d'instruction pour garantir que cette instruction ne sera pas omise en raison de l'optimisation du compilateur et nécessite une lecture directe de la valeur à chaque fois.

Il se peut que de nombreux amis qui viennent d'apprendre Java se sentent encore confus après avoir lu la description très générale ci-dessus.

Utilisons un exemple spécifique pour apprendre à utiliser volatile.

Regardez cet exemple :

public class ThreadVerify {
    public static Boolean stop = false;
    public static void main(String args[]) throws InterruptedException {
        Thread testThread = new Thread(){
            @Override
            public void run(){
                int i = 1;
                while(!stop){
                    //System.out.println("in thread: " + Thread.currentThread() + " i: " + i);
                    i++;
                }
                System.out.println("Thread stop i="+ i);
            }
        }
        ;
        testThread.start();
        Thread.sleep(1000);
        stop = true;
        System.out.println("now, in main thread stop is: " + stop);
        testThread.join();
    }
}

Ce code définit une variable booléenne stop dans la deuxième ligne du thread principal, puis le thread principal démarre un nouveau thread et s'arrête dans le thread . Augmentez la valeur du compteur i jusqu'à ce que la variable booléenne stop du thread principal soit définie sur true par le thread principal avant de terminer la boucle.

Le thread principal fait une pause d'une seconde avec Thread.sleep et définit la valeur booléenne stop sur true.

Par conséquent, le résultat que nous attendons est que le code Java ci-dessus s'arrête après 1 seconde d'exécution et imprime la valeur réelle du compteur i dans 1 seconde valeur.

Cependant, après avoir exécuté cette application Java, vous constatez qu'elle entre dans une boucle infinie. Dans le gestionnaire de tâches, vous constatez que l'utilisation du processeur de ce programme Java monte en flèche.

Quelle est la raison ? Passons en revue les connaissances sur les modèles de mémoire enseignées dans le cours majeur d'informatique Systèmes d'exploitation.

Prenons le modèle de mémoire Java comme exemple. Le modèle de mémoire Java est divisé en mémoire principale et mémoire de travail. Les variables de la mémoire principale sont partagées par tous les threads. Chaque thread possède sa propre mémoire de travail et les variables à l'intérieur incluent des variables locales du thread. Si une variable de la mémoire principale est utilisée par un thread, la mémoire de travail du thread conservera une copie de la variable de la mémoire principale.

Toutes les opérations de lecture et d'écriture des variables par les threads doivent être effectuées dans la mémoire de travail et les variables de la mémoire principale ne peuvent pas être directement manipulées. Différents threads ne peuvent pas accéder directement à la mémoire de travail de chacun. Le transfert de variables entre les threads doit être effectué via la mémoire principale. La relation interactive entre les threads, la mémoire principale et la mémoire de travail est la suivante :

Si le thread modifie la définition dans son propre code d'exécution, les variables dans le thread principal (mémoire principale) sont modifiés directement dans la mémoire de travail du thread, puis à un certain moment (le programmeur Java ne peut pas contrôler ce moment, mais est planifié par la JVM), cette modification est réécrite depuis la mémoire de travail. mémoire principale.

Retour à notre exemple. Bien que le thread principal modifie la variable stop, il ne modifie que la valeur dans la mémoire principale, tandis que la variable stop dans la mémoire de travail du thread qui exploite le compteur a toujours l'ancienne valeur, qui est toujours fausse. Ce fil est donc coincé dans une boucle infinie.

Une fois que l'on connaît le principe, la solution est simple. Ajoutez le mot-clé volatile avant la variable stop pour la modifier, de sorte qu'à chaque fois que la valeur stop est lue dans le thread du compteur, volatile forcera le thread à lire dans la mémoire principale au lieu de lire dans la mémoire de travail du thread actuel. Cela évite une boucle infinie. L'image ci-dessous montre qu'après 1 seconde, le compteur a exécuté 1,4 milliard de fois.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!