Le mot-clé volatil garantit la visibilité des variables et interdit la réorganisation de l'enseignement dans un environnement multi-thread. 1. L'utilisation du volatile peut garantir que la modification des variables par un thread est immédiatement visible par d'autres threads, évitant les valeurs incohérentes causées par le cache CPU; 2. Volatile empêche la réorganisation des instructions par le biais de règles en provenance, garantissant que les modifications avant les opérations d'écriture sont visibles pour les opérations de lecture ultérieures; 3. Il convient à des scénarios simples tels que les indicateurs d'état, tels que les drapeaux d'arrêt; 4. Cependant, il ne garantit pas l'atomicité des opérations composites, comme le nombre, nécessite toujours un mécanisme d'atomicinteger ou de verrouillage; 5. Volatile ne peut pas remplacer le mécanisme de synchronisation pour obtenir une sécurité complète du fil. Par conséquent, le volatile convient aux variables partagées qui sont un thread d'écriture unique, un thread multi-lecture et ne nécessitent pas d'atomicité, mais ne convient pas aux scénarios où des modifications simultanées fréquentes ou nécessitent des opérations atomiques.

Le mot-clé volatile de Java joue un r?le spécifique et important dans la programmation multithread. Ce n'est pas une solution miracle pour la sécurité des fils, mais il résout un problème particulier: la visibilité des variables partagées sur les fils .

Lorsque plusieurs threads accèdent à la même variable, surtout lorsqu'un ou plusieurs threads le modifient, vous pouvez avoir des situations où un thread ne voit pas la valeur la plus récente écrite par une autre. Cela se produit en raison d'optimisations comme la mise en cache du processeur et la réorganisation des instructions. Le mot-clé volatile aide à résoudre ce problème.

Quelles garanties volatile

L'ajout volatile à une déclaration variable garantit deux garanties clés:

1. Visibilité : les modifications d'une variable volatile sont toujours visibles pour d'autres threads. Lorsqu'un thread écrit sur une variable volatile , le JVM garantit que la nouvelle valeur est immédiatement écrite à la mémoire principale, et lorsqu'un autre thread lit cette variable, il lit la dernière valeur de la mémoire principale - pas à partir d'un cache CPU local.

2. Prévention de la réorganisation de l'enseignement : le JVM et le CPU peuvent réorganiser les instructions pour les performances, mais cela peut casser l'exactitude dans le code simultané. volatile impose une relation à se produire , ce qui signifie:

   
   • Toutes les écritures avant une écriture dans une variable volatile sont garanties d'être visibles avant l'écriture.
   • Toutes les lectures après une lecture d'une variable volatile sont garanties de voir les effets de cette lecture et des écritures antérieures.

Cela rend volatile utile dans les drapeaux de signalisation ou les indicateurs d'état.

Exemple: Utilisation volatile comme drapeau d'arrêt

 Le travailleur de classe publique implémente Runnable {
    Running booléen volatile privé = true;

    public void shutdown () {
        running = false;
    }

    @Outrepasser
    public void run () {
        while (running) {
            // fonctionne
        }
        System.out.println ("Le travailleur s'est arrêté.");
    }
}

Sans volatile , le thread Running run() peut mettre en cache la valeur de running dans un registre et ne jamais voir la mise à jour d'un autre thread appelant shutdown() , conduisant à une boucle infinie.

Avec volatile , le thread vérifie la valeur de mémoire principale à chaque fois, il voit donc le changement immédiatement (ou du moins très bient?t, selon le temps).

Ce que volatile ne garantit pas

Il est cruel de comprendre ce que volatile ne fait pas:

• ? Atomicité : la lecture ou l'écriture d'une variable volatile est atomique pour les types simples (comme boolean , int , les références), mais les opérations composées (par exemple, count ) ne le sont pas. Cette expression implique la lecture, la modification, l'écriture - et un autre thread pourrait modifier la valeur entre les deux.

  Exemple:

   volatile int compter = 0;
  comptoir ; // pas atomique!

  Cela peut encore entra?ner des mises à jour perdues. Utilisez plut?t AtomicInteger pour de tels cas.

• ? Sécurité complète du thread : la fabrication d'une variable volatile ne fait pas un filetage de classe. Si plusieurs threads modifient l'état associé, vous avez toujours besoin de synchronisation via des classes synchronized , ReentrantLock ou atomiques.

---

Quand utiliser volatile

Utilisez volatile lorsque:

• ? Vous avez une variable partagée qui est lue par plusieurs threads et écrite par une (ou parfois plus, si l'atomicité n'est pas requise).
• ? Vous l'utilisez comme indicateur d'état (par exemple, shutdownRequested , initialized , ready ).
• ? Vous devez éviter les valeurs obsolètes dues à la mise en cache.
• ? Vous souhaitez assurer la commande d'actions autour de lectures / écritures à cette variable.

évitez volatile lorsque:

• ? Vous effectuez des opérations composées (Read-Modify-Write).
• ? Plusieurs threads mettent à jour la variable fréquemment et l'exactitude dépend de l'atomicité.

---

Résumé

• volatile garantit la visibilité et empêche certaines réorganisations du compilateur / CPU.
• Il est léger par rapport aux blocs synchronized .
• Ce n'est pas un remplacement pour une bonne synchronisation lorsque l'atomicité est requise.
• Mieux utilisé pour les drapeaux simples ou les indicateurs d'état dans des programmes simultanés.

Fondamentalement, volatile est un outil subtil mais puissant - utilisez-le lorsque vous avez besoin de threads pour voir la dernière valeur d'une variable, mais ne vous attendez pas à ce qu'elle gère tout ce qui vous est de concurrence.

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!