Einführung in das Schlüsselwort volatile in der gleichzeitigen Java-Programmierung (mit Beispielen)

Dieser Artikel bietet Ihnen eine Einführung in das flüchtige Schlüsselwort in der Java-Parallelprogrammierung (mit Beispielen). Ich hoffe, dass er Ihnen als Referenz dienen wird.

volatile-Explanation

• Die Rolle des volatilen Schlüsselworts besteht darin, dass Variablen in mehreren Threads sichtbar sind;

• The volatile Schlüsselwort ist nicht- Atomic

• Wenn Sie atomare Operationen implementieren möchten, wird empfohlen, eine Reihe von Objekten der Atomklasse zu verwenden: Unterstützt atomare Operationen (beachten Sie, dass die Atomklasse nur garantiert die Atomizität der eigenen Methode und garantiert nicht die Mehrfachatomarität von Operationen)

1. Volatilität:

• Die Rolle des Volatilitätsfaktors Das Schlüsselwort ist, dass Variablen in mehreren Threads sichtbar sind verfügen über einen Arbeitsspeicherbereich, der von allen Threads gemeinsam genutzte Informationen speichert. Eine Kopie der Variablen im Hauptspeicher. Wenn der Thread ausgeführt wird, werden diese Variablen in seinem eigenen Arbeitsspeicherbereich manipuliert. Um auf eine gemeinsam genutzte Variable zuzugreifen, erhält ein Thread normalerweise zunächst die Sperre und löscht den Speicherarbeitsbereich des aktuellen Threads und lädt diese gemeinsam genutzten Variablen korrekt aus dem gemeinsam genutzten Speicherbereich aller Threads in seinen eigenen Arbeitsspeicherbereich, um sicherzustellen, dass der Thread entsperrt ist dass die Werte von Variablen im Arbeitsspeicher in den Shared-Memory-Bereich geschrieben werden.

* Die Operationen, die ein Thread ausführen kann, sind: verwenden (verwenden), zuweisen (assgin), laden (laden), speichern (speichern), sperren (sperren), entsperren (entsperren). ) ;
* Die Operationen, die im Hauptspeicher ausgeführt werden können, sind: Lesen (Lesen), Schreiben (Schreiben), Sperren (Sperren), Entsperren (Entsperren); jede Operation ist atomar von.

• * Die Funktion von volatile besteht darin, den Thread zu zwingen, Variablen im Hauptspeicher (gemeinsam genutzter Speicher) zu lesen, anstatt im Thread-Arbeitsspeicherbereich zu lesen, wodurch mehrere Threads realisiert werden Die Variablen dazwischen sind sichtbar. Dies erfüllt auch die Thread-sichere Sichtbarkeit.

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

• 2. Das Schlüsselwort volatile ist zwar nicht atomar, hat aber keine Sichtbarkeit zwischen mehreren Threads Sie verfügen über eine Synchronisierung (d. h. Atomizität). Die Leistung ist viel besser als die Synchronisierung und verursacht keine Blockierung (in vielen Open-Source-Architekturen ist der zugrunde liegende Code von Netty flüchtig. Sichtbare Leistung von Netty).

• * Zu beachten: Im Allgemeinen wird „volatil“ für variable Operationen verwendet, die für mehrere Threads sichtbar sind, und kann den Synchronisationseffekt von „synchronized“ nicht ersetzen

Beispiel: concurrent.java

Erklärung:

Das Schlüsselwort volatile hat nur Sichtbarkeit und keine Atomizität.

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

• * Wenn Sie atomare Operationen implementieren möchten, wird empfohlen, eine Reihe von Objekten der Atomklasse zu verwenden: Unterstützt atomare Operationen (beachten Sie, dass die Atomklasse nur die Atomizität von garantiert eine eigene Methode und garantiert keine Atomizität bei mehreren Operationen)

Beispiel:
Erklärung:

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

public class AtomicUse {

private static AtomicInteger count = new AtomicInteger(0);

    //多个addAndGet在一个方法内是非原子性的，需要加synchronized进行修饰，保证4个addAndGet整体原子性
    /**synchronized*/
    public synchronized int multiAdd(){
        try {
          Thread.sleep(100);
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        count.addAndGet(1);
        count.addAndGet(2);
        count.addAndGet(3);
        count.addAndGet(4); //+10
        return count.get();
    }
    public static void main(String[] args) {

      final AtomicUse au = new AtomicUse();

      List<Thread> ts = new ArrayList<Thread>();
      for (int i = 0; i < 100; i++) {
        ts.add(new Thread(new Runnable() {
          @Override
          public void run() {
            System.out.println(au.multiAdd());
          }
        }));
      }
      for(Thread t : ts){
        t.start();
      }
    }
}

Das obige ist der detaillierte Inhalt vonEinführung in das Schlüsselwort volatile in der gleichzeitigen Java-Programmierung (mit Beispielen). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!