¿Qué pasar a la palabra clave de bloqueo?

Question

¿Cuál es la diferencia (si la hay) entre el uso de

void MethodName() 
{ 
    lock(this) 
    { 
     // (...) 
    } 
} 

o

private object o = new object(); 
void MethodName() 
{ 
    lock(o) 
    { 
     // (...) 
    } 
} 

?

¿Hay alguna diferencia en el rendimiento? ¿Estilo? ¿Comportamiento?

Answer 1

La diferencia es que cualquiera puede bloquear su instancia, pero solo usted puede bloquear un objeto privado.

Esto ayuda a prevenir interbloqueos.

Por ejemplo:

Digamos que Microsoft utiliza lock(this) en la clase Control.

Luego, si alguien más se bloquea en una instancia de Control, su bloqueo evitaría que se ejecute el código en Control, que no es lo que él quiere.

Esto es particularmente malo si lock on types that are shared across AppDomains

Answer 2

lock(this) se bloqueará en el objeto "actual".

Bloquear en "esto" suele ser una mala idea, ya que expone el bloqueo a otro código; Yo prefiero tener un campo de sólo lectura, como esto:

public class Foo 
{ 
    private readonly object padlock = new object(); 

    public void SomeMethod() 
    { 
     lock(padlock) 
     { 
      ... 
     } 
    } 
} 

de esa manera todas las llamadas a SomeMethod (y cualquier otra cosa en Foo que bloquea el padlock) se cierran con llave en el mismo monitor de la misma instancia de Foo, pero nada de lo contrario, puede interferir al bloquear ese monitor.

En realidad, a menos que usted está tratando con el código "canalla", es poco probable que otro código se realidad bloqueo en la referencia a una instancia de Foo, pero es una cuestión de encapsulación.

Answer 3

Hay una diferencia en su alcance y no puede haber una diferencia en el comportamiento (dicho sea de paso, el uso de "esto" no es recomendado por MS

 

// in this case, your lock object is public, so classes outside of this can lock on the same thing 
lock(this) {} 

// in this case, your lock is private, and only you can issue a lock statement against it 
private object lockobj = new object() 
.. 
lock(this.lockobj) {} 

// this one is WRONG -- you willget a new object instance every time, so your lock will not provide mutual exclusion 
void SomeMethod() 
{ 
    // using a local variable for a lock -- wrong 
    object obj = new object(); 
    lock(obj) {} 
} 
 

Answer 4

El patrón que suelo seguir es este, para una clase declarada static ....

 
public static class SomeClass{ 
    private static object objLock = new object(); 
    .... 
    public static object SomeProperty{ 
     get{ 
      lock(objLock){ 
      // Do whatever needs to be done 
      } 
     } 
     set{ 
      lock(objLock){ 
      } 
     } 
    } 
} 

Asimismo para una clase normal, me gustaría seguir este patrón:

 
public class SomeClass{ 
    private readonly object objLock = new object(); 
    .... 
    public object SomeProperty{ 
     get{ 
      lock(objLock){ 
      // Do whatever needs to be done 
      } 
     } 
     set{ 
      lock(objLock){ 
      } 
     } 
    } 
} 

De esa manera, nadie puede bloquear en mi instancia y evitará estancamientos de ocurriendo ...

Editar: He modificado este artículo para que sea más clara con respecto al código en la base de la Se usaría static candado y para una clase normal ...Gracias Steven y Dalle por sus salidas de punto ...