C# ¿Pueden las clases múltiples BLOQUEAR el mismo objeto utilizando múltiples referencias?

Question

Quiero hacer varias instancias de esta clase.

public class Worker 
{ 
    private object _lockObject; 
    private Thread _workerThread; 
    private string _name; 

    public Worker(object lockObject, string name) 
    { 
     _name = name; 
     _lockObject = lockObject; 
     _workerThread = new Thread(new ThreadStart(DoWork)); 
     _workerThread.Start(); 
    } 
    private void DoWork() 
    { 
     while(true) 
     { 
      lock(_lockObject) 
      { 
       Console.WriteLine(_name + "Doing Work"); 
      } 
     } 
    } 
} 

Si paso el mismo objeto de bloqueo para múltiples instancias de la clase, será un bloqueo en una instancia de clase resultar en la otra instancia de clase de espera en que el bloqueo de ser libre?

static void Main() 
{ 
    private readonly object sharedLockObject = new object(); 
    Worker a = new Worker(sharedLockObject,"a"); 
    Worker b = new Worker(sharedLockObject,"b"); 
    Console.ReadLine(); 
} 

Creo que en el caso anterior, los trabajadores nunca habrá: Console.WriteLine (_name + "que hace el trabajo"); al mismo tiempo?

Solo me gustaría obtener alguna confirmación, ya que no estoy seguro de si el bloqueo() bloqueará la referencia o el objeto al que se hace referencia.

Gracias!

Answer 1

Sí, object es un tipo de referencia por lo que está pasando una referencia al mismo objeto, por lo que ese mismo objeto sería utilizado por cada Trabajador. El objeto se usa para bloquear, no la referencia.

Answer 2

La declaración lock marcará la instancia del objeto, no la variable de referencia.

lock(x) { 
    ... 
} 

es precisamente equivalente a:

System.Threading.Monitor.Enter(x); 
try { 
    ... 
} 
finally { 
    System.Threading.Monitor.Exit(x); 
} 

donde x es una instancia de objeto de un tipo de referencia.

Así que sí :-)

Answer 3

le recomiendo que no pasar un objeto compartido que se utiliza para bloquear o usted podría conseguir en algunos puntos muertos desagradables. Use un miembro privado de la clase estática para bloquear en:

public class Worker 
{ 
    private static object _syncRoot = new object(); 
    private Thread _workerThread; 
    private string _name; 

    public Worker(string name) 
    { 
     _name = name; 
     _workerThread = new Thread(new ThreadStart(DoWork)); 
     _workerThread.Start(); 
    } 
    private void DoWork() 
    { 
     while(true) 
     { 
      lock(_syncRoot) 
      { 
       Console.WriteLine(_name + "Doing Work"); 
      } 
     } 
    } 
} 

Answer 4

lo que está haciendo el trabajo voluntad, pero por qué no hacer que el _lockObject miembro de la clase staticWorker? Conseguirá el mismo efecto pero está más orientado a objetos.

public class Worker 
{ 
    private static object _lockObject = new object(); 
    private Thread _workerThread; 
    private string _name; 

    public Worker(string name) 
    { 
     _name = name; 
     _workerThread = new Thread(new ThreadStart(DoWork)); 
     _workerThread.Start(); 
    } 
    private void DoWork() 
    { 
     while(true) 
     { 
      lock(_lockObject) 
      { 
       Console.WriteLine(_name + "Doing Work"); 
      } 
     } 
    } 
} 

EDITAR: ¡Huy! No vi la respuesta de @Darin Dimitrov, que es idéntica a la que he publicado aquí. +1 a ti, Darin.