Intrinsic Schlösser und Synchronisation

Question

ich zur Zeit über Intrinsic Locks and Synchronization auf oracle.com lese, wo ich zu diesem besonderen Beispiel kam:

Synchronisierte Aussagen sind auch nützlich für die Gleichzeitigkeit mit feinkörnigem Synchronisation zu verbessern. Angenommen, die Klasse MsLunch hat beispielsweise zwei Instanzfelder, c1 und c2, die niemals zusammen verwendet werden. Alle Updates dieser Felder müssen synchronisiert werden, aber es gibt keinen Grund zu verhindern, dass eine Aktualisierung von c1 mit einer Aktualisierung von c2 verschachtelt wird - und dies reduziert die Nebenläufigkeit, indem eine unnötige Blockierung erzeugt wird. Anstatt synchronisierte Methoden zu verwenden oder die damit verbundene Sperre anderweitig zu verwenden, erstellen wir zwei Objekte, um nur Sperren bereitzustellen.

public class MsLunch { 
    private long c1 = 0; 
    private long c2 = 0; 
    private Object lock1 = new Object(); 
    private Object lock2 = new Object(); 

    public void inc1() { 
     synchronized(lock1) { 
      c1++; 
     } 
    } 

    public void inc2() { 
     synchronized(lock2) { 
      c2++; 
     } 
    } 
} 

Vor diesem Abschnitt synchronized Verfahren, in denen erklärt:

public synchronized void increment() { 
    this.c++; 
} 

Welche sein sollte, und mir bitte korrigieren, wenn ich falsch bin, das gleiche wie

public void increment() { 
    synchronized(this) { 
     c++; 
    } 
} 

wenn Ich füge keine Funktionalität zu increment() hinzu, ist das richtig?

Meine Frage ist jetzt aus dem Satz kommt:

aber es gibt keinen Grund, ein Update von c1 zu verhindern, dass verschachtelte mit einem Update von c2

sein Ich bin nicht sicher, ob ich vollständig verstehen, was "interleaved" bedeutet in diesem Zusammenhang. Bedeutet es, dass wenn ich z.B. entfernen lock2 aus dem MsLunch Beispiel:

public class MsLunch { 
    private long c1 = 0; 
    private long c2 = 0; 
    private Object lock1 = new Object(); 
    // private Object lock2 = new Object(); // 'lock2' is no more! 

    public void inc1() { 
     synchronized(lock1) { 
      c1++; 
     } 
    } 

    public void inc2() { 
     synchronized(lock1) { // Using 'lock1' here too 
      c2++; 
     } 
    } 
} 

ich in Schwierigkeiten mit Sperren bekommen? Sagen thread-1 läuft in , erhält die Sperre von lock1, aber wird ausgesetzt, bevor in der Lage sein, die Sperre zu erhöhen oder zu lösen. Jetzt thread-2 wird inc2() eingeben, wo eine andere Sperre für lock1 erstellt wird. Wird das vermieden, indem ein anderer lock2 verwendet wird und ist das der Grund, warum ich nicht einfach this als Lock-Provider verwenden würde? Oder mit anderen Worten: Kann das ein Problem verursachen?

Answer 1

Zwei Schlösser hier nur um die Möglichkeit zu haben, c1 und c2 unabhängig zu erhöhen und nicht zu warten, wenn das Schloss freigegeben wird. Wenn also Thread-1 in den Synchronisierungsblock in c1 eintritt und einen lock1 erwirbt, kann ein weiterer Thread-2c2 erhöhen, ohne zu warten, wenn thread-1 eine Sperre freigibt.

---

Wichtig zu beachten:

Verwendung von this als Aktien-Monitor eine eigene Ausgabe hat, weil ein Verweis auf die Instanz von MsLunch sichtbar außerhalb von MsLunch ist. Beispielsweise.Thread-3 kann ein Schloss für: synchronized (msLunchInstance) außerhalb dieser Klasse erwerben.