Synchronisation des nicht endgültigen Feldes

Jedes Mal, wenn ich in einem nicht endgültigen Klassenfeld synchronisiere, wird eine Warnung angezeigt. Hier ist der Code:

public class X  
{  
   private Object o;  

   public void setO(Object o)  
   {  
     this.o = o;  
   }  

   public void x()  
   {  
     synchronized (o) // synchronization on a non-final field  
     {  
     }  
   }  
 } 

Deshalb habe ich die Codierung folgendermaßen geändert:

 public class X  
 {  

   private final Object o;       
   public X()
   {  
     o = new Object();  
   }  

   public void x()  
   {  
     synchronized (o)
     {  
     }  
   }  
 }  

Ich bin nicht sicher, ob der obige Code der richtige Weg ist, um in einem nicht endgültigen Klassenfeld zu synchronisieren. Wie kann ich ein nicht endgültiges Feld synchronisieren?

Zunächst möchte ich Sie ermutigen, sich wirklich zu bemühen, Parallelitätsprobleme auf einer höheren Abstraktionsebene zu lösen, dh sie mithilfe von Klassen aus java.util.concurrent wie ExecutorServices, Callables, Futures usw. zu lösen.

Davon abgesehen ist nichts falsch daran, auf einem nicht endgültigen Feld per se zu synchronisieren. Sie müssen nur berücksichtigen, dass bei einer Änderung der Objektreferenz möglicherweise derselbe Codeabschnitt parallel ausgeführt wird . Das heißt, wenn ein Thread den Code im synchronisierten Block ausführt und jemand aufruft setO(...), kann ein anderer Thread denselben synchronisierten Block gleichzeitig auf derselben Instanz ausführen.

Synchronisieren Sie das Objekt, auf das Sie exklusiven Zugriff benötigen (oder besser noch ein Objekt, das für die Bewachung vorgesehen ist).

Das ist wirklich keine gute Idee, da Ihre synchronisierten Blöcke nicht mehr wirklich konsistent synchronisiert sind .

Angenommen, die synchronisierten Blöcke sollen sicherstellen, dass jeweils nur ein Thread auf gemeinsam genutzte Daten zugreift. Beachten Sie Folgendes:

• Thread 1 tritt in den synchronisierten Block ein. Ja - es hat exklusiven Zugriff auf die freigegebenen Daten ...
• Thread 2 ruft setO () auf
• Thread 3 (oder noch 2 ...) tritt in den synchronisierten Block ein. Eek! Es glaubt, dass es exklusiven Zugriff auf die gemeinsam genutzten Daten hat, aber Thread 1 läuft immer noch damit ...

Warum würden Sie wollen dies geschehen? Vielleicht gibt es einige sehr spezielle Situationen, in denen es sinnvoll ist ... aber Sie müssten mir einen bestimmten Anwendungsfall (zusammen mit Möglichkeiten zur Abschwächung des oben angegebenen Szenarios) vorstellen, bevor ich zufrieden bin es.

Ich stimme einem Kommentar von John zu: Sie müssen beim Zugriff auf eine nicht endgültige Variable immer einen Dummy für die endgültige Sperre verwenden, um Inkonsistenzen bei Referenzänderungen der Variablen zu vermeiden. Also auf jeden Fall und als erste Faustregel:

Regel 1: Wenn ein Feld nicht endgültig ist, verwenden Sie immer einen (privaten) Dummy für die endgültige Sperre.

Grund Nr. 1: Sie halten die Sperre und ändern die Referenz der Variablen selbst. Ein anderer Thread, der außerhalb der synchronisierten Sperre wartet, kann in den geschützten Block eintreten.

Grund Nr. 2: Sie halten die Sperre und ein anderer Thread ändert die Referenz der Variablen. Das Ergebnis ist das gleiche: Ein anderer Thread kann in den geschützten Block eintreten.

Bei Verwendung eines Dummy für die endgültige Sperre gibt es jedoch ein weiteres Problem : Möglicherweise werden falsche Daten angezeigt, da Ihr nicht endgültiges Objekt nur beim Aufruf von synchronize (Objekt) mit dem RAM synchronisiert wird. Als zweite Faustregel gilt:

Regel 2: Wenn Sie ein nicht endgültiges Objekt sperren, müssen Sie immer beides tun: Verwenden eines endgültigen Sperr-Dummys und der Sperre des nicht endgültigen Objekts für die RAM-Synchronisation. (Die einzige Alternative besteht darin, alle Felder des Objekts als flüchtig zu deklarieren!)

Diese Sperren werden auch als "verschachtelte Sperren" bezeichnet. Beachten Sie, dass Sie sie immer in derselben Reihenfolge aufrufen müssen, da Sie sonst ein Deadlock erhalten :

public class X {
    private final LOCK;
    private Object o;

    public void setO(Object o){
        this.o = o;  
    }  

    public void x() {
        synchronized (LOCK) {
        synchronized(o){
            //do something with o...
        }
        }  
    }  
} 

Wie Sie sehen, schreibe ich die beiden Schlösser direkt in dieselbe Zeile, weil sie immer zusammen gehören. Auf diese Weise können Sie sogar 10 Verschachtelungssperren erstellen:

synchronized (LOCK1) {
synchronized (LOCK2) {
synchronized (LOCK3) {
synchronized (LOCK4) {
    //entering the locked space
}
}
}
}

Beachten Sie, dass dieser Code nicht beschädigt wird, wenn Sie nur eine innere Sperre wie synchronized (LOCK3)bei einem anderen Thread erwerben . Aber es wird kaputt gehen, wenn Sie einen anderen Thread wie diesen aufrufen:

synchronized (LOCK4) {
synchronized (LOCK1) {  //dead lock!
synchronized (LOCK3) {
synchronized (LOCK2) {
    //will never enter here...
}
}
}
}

Es gibt nur eine Problemumgehung für solche verschachtelten Sperren beim Behandeln nicht endgültiger Felder:

Regel 2 - Alternative: Deklarieren Sie alle Felder des Objekts als flüchtig. (Ich werde hier nicht über die Nachteile sprechen, z. B. das Verhindern von Speicher in X-Level-Caches, auch für Lesevorgänge.)

Aioobe ist also ganz richtig: Verwenden Sie einfach java.util.concurrent. Oder beginnen Sie, alles über die Synchronisierung zu verstehen, und tun Sie dies selbst mit verschachtelten Sperren. ;)

Weitere Informationen dazu, warum die Synchronisierung bei nicht endgültigen Feldern unterbrochen wird, finden Sie in meinem Testfall: https://stackoverflow.com/a/21460055/2012947

Weitere Informationen dazu, warum Sie aufgrund von RAM und Caches überhaupt synchronisiert werden müssen, finden Sie hier: https://stackoverflow.com/a/21409975/2012947

Ich sehe hier nicht wirklich die richtige Antwort, das heißt, es ist vollkommen in Ordnung, dies zu tun.

Ich bin mir nicht mal sicher, warum es eine Warnung ist, daran ist nichts auszusetzen. Die JVM stellt sicher , dass Sie erhalten ein gültiges Objekt zurück (oder null) , wenn Sie einen Wert lesen, und Sie können auf synchronisieren jedes Objekt.

Wenn Sie vorhaben, die Sperre während der Verwendung tatsächlich zu ändern (anstatt sie beispielsweise von einer Init-Methode zu ändern, bevor Sie sie verwenden), müssen Sie die Variable festlegen, die Sie ändern möchten volatile. Dann alles , was Sie tun müssen, ist auf die Synchronisierung sowohl dem alten und dem neuen Objekt, und Sie können sicher den Wert ändern

public volatile Object lock;

...

synchronized (lock) {
    synchronized (newObject) {
        lock = newObject;
    }
}

Dort. Es ist nicht kompliziert, das Schreiben von Code mit Sperren (Mutexen) ist eigentlich recht einfach. Das Schreiben von Code ohne sie (sperrfreier Code) ist schwierig.

EDIT: Diese Lösung (wie von Jon Skeet vorgeschlagen) hat möglicherweise ein Problem mit der Atomizität der Implementierung von "synchronized (object) {}", während sich die Objektreferenz ändert. Ich habe separat gefragt und laut Mr. Erickson ist es nicht threadsicher - siehe: Ist die Eingabe eines synchronisierten Blocks atomar? . Nehmen Sie es als Beispiel, wie man es NICHT macht - mit Links warum;)

Sehen Sie sich den Code an, wie es funktionieren würde, wenn synchronized () atomar wäre:

public class Main {
    static class Config{
        char a='0';
        char b='0';
        public void log(){
            synchronized(this){
                System.out.println(""+a+","+b);
            }
        }
    }

    static Config cfg = new Config();

    static class Doer extends Thread {
        char id;

        Doer(char id) {
            this.id = id;
        }

        public void mySleep(long ms){
            try{Thread.sleep(ms);}catch(Exception ex){ex.printStackTrace();}
        }

        public void run() {
            System.out.println("Doer "+id+" beg");
            if(id == 'X'){
                synchronized (cfg){
                    cfg.a=id;
                    mySleep(1000);
                    // do not forget to put synchronize(cfg) over setting new cfg - otherwise following will happend
                    // here it would be modifying different cfg (cos Y will change it).
                    // Another problem would be that new cfg would be in parallel modified by Z cos synchronized is applied on new object
                    cfg.b=id;
                }
            }
            if(id == 'Y'){
                mySleep(333);
                synchronized(cfg) // comment this and you will see inconsistency in log - if you keep it I think all is ok
                {
                    cfg = new Config();  // introduce new configuration
                    // be aware - don't expect here to be synchronized on new cfg!
                    // Z might already get a lock
                }
            }
            if(id == 'Z'){
                mySleep(666);
                synchronized (cfg){
                    cfg.a=id;
                    mySleep(100);
                    cfg.b=id;
                }
            }
            System.out.println("Doer "+id+" end");
            cfg.log();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Doer X = new Doer('X');
        Doer Y = new Doer('Y');
        Doer Z = new Doer('Z');
        X.start();
        Y.start();
        Z.start();
    }

}

AtomicReference passt zu Ihrer Anforderung.

Von Java - Dokumentation über Atom- Paket:

Ein kleines Toolkit mit Klassen, die eine sperrenfreie threadsichere Programmierung für einzelne Variablen unterstützen. Im Wesentlichen erweitern die Klassen in diesem Paket den Begriff der flüchtigen Werte, Felder und Array-Elemente auf diejenigen, die auch eine atomare bedingte Aktualisierungsoperation des Formulars bereitstellen:

boolean compareAndSet(expectedValue, updateValue);

Beispielcode:

String initialReference = "value 1";

AtomicReference<String> someRef =
    new AtomicReference<String>(initialReference);

String newReference = "value 2";
boolean exchanged = someRef.compareAndSet(initialReference, newReference);
System.out.println("exchanged: " + exchanged);

Im obigen Beispiel ersetzen Sie durch StringIhr eigenesObject

Verwandte SE-Frage:

Wann wird AtomicReference in Java verwendet?

Wenn osich während der Lebensdauer einer Instanz von nie ändert X, ist die zweite Version besser, unabhängig davon, ob es sich um eine Synchronisierung handelt.

Ob mit der ersten Version etwas nicht stimmt, kann nicht beantwortet werden, ohne zu wissen, was in dieser Klasse noch vor sich geht. Ich würde dem Compiler eher zustimmen, dass er fehleranfällig aussieht (ich werde nicht wiederholen, was die anderen gesagt haben).

Ich füge nur meine zwei Cent hinzu: Ich hatte diese Warnung, als ich eine Komponente verwendete, die durch den Designer instanziiert wurde, sodass das Feld nicht wirklich endgültig sein kann, da der Konstruktor keine Parameter annehmen kann. Mit anderen Worten, ich hatte ein quasi endgültiges Feld ohne das endgültige Schlüsselwort.

Ich denke, deshalb ist es nur eine Warnung: Sie machen wahrscheinlich etwas falsch, aber es könnte auch richtig sein.