Sincronización en "esto" o en un objeto privado en Java?

Question

Duplicar posible:
Avoid synchronized(this) in Java?

¿Cuál es la diferencia entre las dos piezas de código? ¿Cuáles son las ventajas y desventajas de cada uno?

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

La razón principal por la que elegiría el segundo enfoque es que no controlo lo que los clientes hacen con las instancias de la clase.

Si, por alguna razón, alguien decide utilizar una instancia de mi clase como un bloqueo, interferirán con la lógica de sincronización dentro de mi clase:

class ClientCode { 
    Example exampleInstance; 

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

Si, dentro de mi clase Example, I' Usando un candado que nadie más puede ver, no pueden interferir con mi lógica e introducir un mutex arbitrario como en el escenario anterior.

En resumen, esta es solo una aplicación del principio de ocultamiento de información.

Answer 2

Yo diría que el segundo método es mejor. Considere la siguiente situación:

public class Abc{ 

    private int someVariable; 

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

     //some method, and again synchronize on this 


} 

En esta situación this no es el mismo en los dos métodos. Uno es un método de la clase interna. Por lo tanto, es mejor usar un objeto común para la sincronización. Por ejemplo, synchronized (someVariable).

Answer 3

Preferiría la segunda opción si necesito ejecutar dos tareas diferentes simultáneamente que son independientes entre sí.

ej .:

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

Creo que realmente depende de la situación. Digamos que tu clase es una subclase y la superclase tiene un método que tiene sincronización. Y digamos que está trabajando con el mismo conjunto de datos y desea mantener la integridad dentro de su método también. Entonces definitivamente el acercamiento 1 es lo que deberías estar usando.

De lo contrario segundo enfoque funcionaría mejor en base a lo mencionado Costi