Welche Klassen in Java sind threadsicher?

Der Kern des Schreibens von Thread-sicherem Code liegt in der Verwaltung von Zustandszugriffsvorgängen, insbesondere des Zugriffs auf gemeinsam genutzte und veränderliche Zustände. Wenn mehrere Threads auf eine Zustandsvariable zugreifen und ein Thread einen Schreibvorgang ausführt, muss ein Synchronisierungsmechanismus verwendet werden, um den Zugriff der Threads auf die Variable zu koordinieren. Zustandslose Objekte müssen Thread-sicher sein.

Was passiert, wenn wir einem zustandslosen Objekt einen Zustand hinzufügen?

Angenommen, wir fügen im Servlet einen „Trefferzähler“ hinzu, um die Anzahl der Anfragen auf folgende Weise zu verwalten: Fügen Sie im Servlet ein langes Feld hinzu und addieren Sie bei jeder Anfrage 1 zu diesem Wert verarbeitet wird.

public class UnsafeCountingFactorizer implements Servlet {
     private long count = 0;
 
     public long getCount() {
            return count ;
     }
 
     @Override
     public void service(ServletRequest arg0, ServletResponse arg1)
                 throws ServletException, IOException {
            // do something
           count++;
     }
}

Leider ist der obige Code nicht threadsicher, da count++ keine atomare Operation ist. Tatsächlich enthält er drei separate Operationen: den Wert von count lesen, 1 zum Wert addieren und dann berechnen Das Ergebnis wird in count geschrieben. Wenn Thread A liest, dass die Anzahl 10 beträgt, liest Thread B sofort, dass die Anzahl ebenfalls 10 beträgt. Thread A addiert 1 und schreibt auf 11. Thread B hat bereits gelesen, dass die Anzahl 10 beträgt, also ist sie nach dem Hinzufügen von 1 und dem Schreiben immer noch 11. Eine Zählung geht somit verloren.

Bei der gleichzeitigen Programmierung ist ein solches falsches Ergebnis aufgrund eines falschen Ausführungszeitpunkts eine sehr wichtige Situation. Es hat einen formalen Namen: Rennbedingung. Die häufigste Art von Race-Bedingung ist die Operation „Zuerst prüfen und dann ausführen“, d. h. ein potenziell ungültiges Beobachtungsergebnis wird verwendet, um die nächste Operation zu bestimmen Race-Bedingungen:

public class LazyInitRace {
     private SomeObject instance = null;
     public SomeObject getInstance() {
            if(instance == null)
                 instance = new SomeObject();
            return instance ;
     }
}

Enthält eine Race-Bedingung in LazyInitRace: Zuerst stellt Thread A fest, dass die Instanz null ist, dann bestimmt Thread B, dass die Instanz ebenfalls null ist, und dann erstellen Thread A und Thread B jeweils Objekte , sodass das Objekt zwei Prozesse durchläuft. Bei der Initialisierung ist ein Fehler aufgetreten. Um statische Bedingungen zu vermeiden, müssen Sie verhindern, dass andere Threads diese Variable auf irgendeine Weise verwenden, wenn ein Thread die Variable ändert. Dadurch wird sichergestellt, dass andere Threads den Status nur vor oder nach Abschluss des Änderungsvorgangs lesen und ändern können . , anstatt den Zustand zu ändern.

Im UnsafeCountingFactorizer-Beispiel ist der Thread unsicher, weil count++ keine atomare Operation ist. Wir können eine atomare Klasse verwenden, um sicherzustellen, dass die Additionsoperation atomar ist Auf diese Weise ist die Klasse threadsicher:

 public class CountingFactorizer implements Servlet {
     private final AtomicLong count = new AtomicLong(0);
 
    public long getCount() {
          return count .get() ;
   }
 
    @Override
    public void service(ServletRequest arg0, ServletResponse arg1)
               throws ServletException, IOException {
          // do something
          count.incrementAndGet();
   }
}

AtomicLong ist eine atomare Variablenklasse im Paket java.util.concurrent.atomic. Sie kann atomare automatische Inkrementierungsoperationen implementieren, ist also threadsicher. sicher.

Verwandte Lernempfehlungen: Java Basic Tutorial

Das obige ist der detaillierte Inhalt vonWelche Klassen in Java sind threadsicher?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!