Introduction au mot-clé volatile dans la programmation simultanée Java (avec exemples)

Cet article vous présente une introduction au mot-clé volatile dans la programmation simultanée Java (avec des exemples). Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

volatile-Explication

• Le rôle du mot-clé volatile est que les variables sont visibles dans plusieurs threads

• Le volatile ; le mot-clé est non atomique

• Si vous souhaitez implémenter des opérations atomiques, il est recommandé d'utiliser une série d'objets de la classe atomique : prendre en charge les opérations atomiques (notez que la classe atomique ne garantit que l'atomicité de sa propre méthode, et ne garantit pas plusieurs fois l'atomicité des opérations)

1. Le mot-clé est que les variables sont visibles dans plusieurs threads ;

• Exemple :
RunThread.java

Explication :En Java, chaque thread sera avoir une zone de mémoire de travail, qui stocke les informations partagées par tous les threads. Une copie de la variable dans la mémoire principale. Lorsque le thread s'exécute, ces variables sont manipulées dans sa propre zone de mémoire de travail. Afin d'accéder à une variable partagée, un thread obtient généralement d'abord le verrou et efface la zone de travail de la mémoire du thread actuel, et charge correctement ces variables partagées de la zone de mémoire partagée de tous les threads dans sa propre zone de mémoire de travail. que les valeurs des variables de la mémoire de travail sont écrites dans la zone de mémoire partagée.
* Les opérations qu'un thread peut effectuer sont : utiliser (utiliser), affectation (assgin), charger (charger), stocker (stocker), verrouiller (verrouiller), déverrouiller (déverrouiller). ) ;

• * Les opérations qui peuvent être effectuées dans la mémoire principale sont : lire (lire), écrire (écrire), verrouiller (verrouiller), déverrouiller (déverrouiller) ; chaque opération est atomique ; de.

• * La fonction de volatile est de forcer le thread à lire les variables dans la mémoire principale (mémoire partagée) au lieu de lire dans la zone de mémoire de travail du thread, réalisant ainsi plusieurs threads Les variables entre sont visibles. Cela répond également à la visibilité thread-safe ;

• 2. Le mot-clé volatile n'est pas atomique

Bien que le mot-clé volatile ait une visibilité sur plusieurs threads, il le fait. n'a pas de synchronisation (c'est-à-dire d'atomicité), peut être considéré comme une synchronisation légère, les performances sont bien meilleures que celles synchronisées et ne provoqueront pas de blocage (dans de nombreuses architectures open source : le code sous-jacent de Netty peut être utilisé en grande quantité volatile, visible netty)

public class RunThread extends Thread{

    private volatile boolean isRunning = true;
    private void setRunning(boolean isRunning){
        this.isRunning = isRunning;
    }

    public void run(){
        System.out.println("进入run方法..");
        int i = 0;
        while(isRunning == true){
            //..
        }
        System.out.println("线程停止");
    }

    public static void main(String[] args) throws InterruptedException {
        RunThread rt = new RunThread();
        rt.start();
        Thread.sleep(1000);
        rt.setRunning(false);
        System.out.println("isRunning的值已经被设置了false");
    }
}

* Choses à noter : généralement volatile est utilisé pour les opérations variables visibles par plusieurs threads et ne peut pas remplacer l'effet de synchronisation de synchronisé

• Exemple : concurrent.java

Explication : Le mot-clé volatile n'a qu'une visibilité et aucune atomicité.

* Si vous souhaitez implémenter des opérations atomiques, il est recommandé d'utiliser une série d'objets de la classe atomique : prendre en charge les opérations atomiques (à noter que la classe atomique ne garantit que la atomicité de ses propres méthodes, et ne garantit pas l'atomicité multiple des opérations)

import java.util.concurrent.atomic.AtomicInteger;
/**
* volatile关键字不具备synchronized关键字的原子性（同步）
* @@author Maozw
*
*/
public class VolatileNoAtomic extends Thread{
    //private static volatile int count;
    private static AtomicInteger count = new AtomicInteger(0);
    private static void addCount(){
      for (int i = 0; i < 1000; i++) {
        //count++ ;
        count.incrementAndGet();
      }
      System.out.println(count);
    }

    public void run(){
      addCount();
    }

    public static void main(String[] args) {

      VolatileNoAtomic[] arr = new VolatileNoAtomic[100];
      for (int i = 0; i < 10; i++) {
        arr[i] = new VolatileNoAtomic();
      }

      for (int i = 0; i < 10; i++) {
        arr[i].start();
      }
    }
}

• Exemple :

Description :

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!