Synchronisation auf "diesem" oder privaten Objekt in Java?

Question

Mögliche Duplizieren:
Avoid synchronized(this) in Java?

Was ist der Unterschied zwischen den beiden Teilen des Codes? Was sind Vor- und Nachteile von jedem?

1)

public class Example { 
private int value = 0; 

public int getNextValue() { 
    synchronized (this) { 
     return value++; 
    } 
} 
} 

2)

public class Example { 
private int value = 0; 

private final Object lock = new Object(); 

public int getNextValue() { 
    synchronized (lock) { 
     return value++; 
    } 
} 
} 

Answer 1

Der Hauptgrund, warum ich den zweiten Ansatz wählen würde, ist, dass ich nicht kontrollieren, was die Kunden mit den Instanzen meiner Klasse zu tun.

Wenn aus irgendeinem Grund, jemand eine Instanz meiner Klasse als Sperre verwenden entscheidet, werden sie mit der Synchronisationslogik innerhalb meiner Klasse stören:

class ClientCode { 
    Example exampleInstance; 

    void someMethod() { 
     synchronized (exampleInstance) { 
      //... 
     } 
    } 
} 

Wenn innerhalb meiner Example Klasse, ich m mit einer Sperre, die niemand sonst sehen kann, können sie meine Logik nicht stören und einen willkürlichen Mutex einführen, wie im obigen Szenario.

Zusammenfassend ist dies nur eine Anwendung des Information-Hiding-Prinzips.

Answer 2

Ich würde sagen, dass die zweite Methode ist besser. Betrachten Sie die folgende Situation:

public class Abc{ 

    private int someVariable; 

    public class Xyz { 
     //some method,synchronize on this 
    } 

     //some method, and again synchronize on this 


} 

In dieser Situation this ist nicht das gleiche in den beiden Methoden. Man ist eine Methode der inneren Klasse. Daher ist es besser, ein gemeinsames Objekt für die Synchronisation zu verwenden. Zum Beispiel synchronized (someVariable).

Answer 3

Ich würde die zweite Option bevorzugen, wenn ich zwei verschiedene Aufgaben gleichzeitig ausführen müssen, die unabhängig voneinander sind.

z.B .:

public class Example { 
    private int value = 0; 
    private int new_value = 0; 
    private final Object lock1 = new Object(); 
    private final Object lock2 = new Object(); 

    public int getNextValue() { 
     synchronized (lock1) { 
      return value++; 
     } 
    } 

    public int getNextNewValue() { 
     synchronized (lock2) {    
      return new_value++; 
     } 
    } 
} 

Answer 4

Ich denke, es hängt wirklich von der Situation ab. Nehmen wir an, Ihre Klasse ist eine Unterklasse und die Superklasse hat eine Methode, die eine Synchronisation hat. Nehmen wir an, Sie arbeiten mit demselben Datensatz und möchten auch die Integrität Ihrer Methode erhalten. Dann definitiv Ansatz 1 ist, was Sie verwenden sollten.

Ansonsten zweiter Ansatz funktionieren würde besser auf, was Costi

erwähnt