Sincronización de los parámetros formales en java

Question

Digamos que tengo un método, al que se accede por dos o más subprocesos y quiero que sea seguro para subprocesos.

public int getVal(int x, int y, MyClass myObj) 
{ 
    int z; 

    z = getInt(myObj); 

    return x + y + z; 
} 

En esto, creo que no tenemos que sincronizar para x + y ya que son primitivos.

Supongamos que getInt(myObj) modifica el estado de myObj y que influye en el valor de z.

Por lo tanto, tendré que proporcionar la sincronización para la línea z = getInt(myObj); pero solo cuando ambos hilos pasen la misma instancia en la referencia 'myObj'. Como el codificador de la API no sabría si ambos hilos pasarían la misma instancia para 'myObj' o no. En algunos casos, estos hilos pueden pasar la misma instancia de MyClass en la referencia 'myObj' y en otros casos pueden pasar diferentes instancias de MyClass en la referencia 'myObj'.

Entonces, ¿cómo se puede garantizar la seguridad del hilo para la línea z = getInt(myObj)? (Seguramente, no queremos sincronizar cuando las instancias pasadas son diferentes y solo tienen que sincronizarse cuando las instancias pasadas son iguales. Es claro que esto no se puede determinar).

Suponiendo que MyClass no se puede convertir en inmutable, creo que lo siguiente podría ser una solución.

synchronized(myObj) 
{ 
    z = getInt(myObj); 
} 

¿Es la solución correcta? Y, en lo que otras maneras podemos garantizar la seguridad de los subprocesos para

z = getInt(myObj); (but only in case of different instances)? 

Answer 1

Para contestar "y, en lo que son las formas podemos garantizar la seguridad de rosca para ... pero sólo en caso de diferentes instancias", sincronizar la totalidad método o crear otro objeto común para actuar como un bloqueo para todos los hilos y sincronizar en él en lugar de myObj.

Answer 2

Lo que tiene es correcto. Cuando synchronize en un objeto está bloqueando en esa instancia no en esa clase. Entonces, si paso la misma instancia * de un objeto a dos métodos diferentes, se bloqueará en ese objeto correctamente. Sin embargo, si paso dos instancias diferentes, no habrá ningún bloqueo porque dos instancias tienen cada uno su propia cerradura .

Answer 3

Si getInt no modifica el estado de this, entonces el método es seguro para subprocesos. La seguridad de subprocesos del objeto myObj es la responsabilidad de su clase: MyClass, o del objeto que lo contiene. No es responsabilidad de todos los métodos que podrían tomarlo como argumento, en mi humilde opinión.

Su solución (synchronized(myObj)) es correcta, sin embargo: dos hilos no podrán ejecutar el método getInt al mismo tiempo si se usa el mismo myObj en ambos hilos. Se ejecutarán concurrentemente si los dos myObjs son diferentes.

Answer 4

Si los únicos cambios en myObject en cuestión provienen de este método getInt, entonces la sincronización es suficiente. Si hay otros modificadores, asegúrese de que se sincronicen en el mismo objeto.

Answer 5

No estoy de acuerdo con todas las respuestas "su sincronizado es correcto". ¿Qué sucede si el usuario tiene 2 hilos y uno de ellos ya tiene bloqueado el objeto? Se producen bloqueos.

Además, x + y + z no es atómico. A nivel de la CPU, que va a convertirse en

int temp = x + y; 
int res = temp + z; 

Te diré más: LONG1 + long2 no es atómica en máquinas de 32 bits.

Creo que su única opción es sincronizar todo el método.

Answer 6

synchronized(myObj) { z = getInt(myObj); } 

hará lo que usted desea, pero la sincronización en un parámetro crea muchos otros problemas. Por ejemplo, es posible que algún otro subproceso ya se esté sincronizando en ese objeto (p. Ej., Tal vez ese objeto tenga un método sincronizado al que se está llamando) y podría entrar en un caso de interbloqueo.

La sincronización debe ser encapsulada como cualquier otra cosa. La mejor solución sería agregar el método getInt al MyClass y sincronizar en algún miembro privado dentro de ese método. De esta forma, nadie más puede ensuciar con lo que está utilizando para implementar su sincronización.

ej .:

public class MyClass { 
    private Object lockObject = new Object(); 
    public int getInt() { 
    synchronized(lockObject) { 
     // do your thing 
    } 
    } 
} 

ver esto: Avoid synchronized(this) in Java? en referencia a la importancia de encapsular su sincronización.