dentro de una cerradura

Question

me di cuenta el siguiente código de nuestros programadores extranjeros:

private Client[] clients = new Client[0]; 

public CreateClients(int count) 
{ 
    lock (clients) 
    { 
     clients = new Client[count]; 

     for(int i=0; i<count; i++) 
     { 
      Client[i] = new Client();//Stripped 
     } 
    } 
} 

No es adecuado código exactamente pero me preguntaba qué es exactamente esto va a hacer. ¿Esto se bloqueará en un nuevo objeto cada vez que se llame a este método?

Answer 1

Para responder a su pregunta de "¿Me preguntaba qué es exactamente esto va a hacer" considere lo que sucede si dos hilos trata de hacer esto

Thread 1: locks on the clients reference, which is `new Client[0]` 
    Thread 1 has entered the critical block 
Thread 1: makes a array and assigns it to the clients reference 
Thread 2: locks on the clients reference, which is the array just made in thread 1 
    Thread 2 has entered the critical block 

Sabe que tiene dos hilos en el bloque crítico al mismo tiempo. Eso es malo.

Answer 2

Este código es incorrecto: se bloqueará en una nueva instancia cada vez que se llame.

Debe quedar como que:

private static readonly object clientsLock = new object(); 
private static string[] Clients = null; 

public CreateClients(int count) 
{ 
    if(clients == null) 
    { 
     lock (clientsLock) 
     { 
      if(clients == null) 
      { 
       clients = new string[count]; 

       for(int i=0; i<count; i++) 
       { 
        client[i] = new Client();//Stripped 
       } 
      } 
     } 
    } 
} 

No hay ningún punto en el bloqueo cada vez que el método se llama - es por eso que rodea el caso de la cláusula.

Answer 3

Uso:
private object = new Object();

lock(object){ 

//your code 

} 

Answer 4

creo que tiene usted razón para dudar de este código!

Este código se bloqueará en la instancia anterior cada vez; este podría ser el efecto deseado, pero lo dudo. No evitará que múltiples hilos creen múltiples matrices.

Answer 5

Este lock realmente no hace nada. Bloquea una instancia de un objeto que se cambia inmediatamente para que otros hilos que ingresen a este método sean lock en un objeto diferente. El resultado es 2 hilos que se ejecutan en el medio del lock, que probablemente no es lo que se pretendía.

Un enfoque mucho mejor es usar un objeto que no cambian diferente para bloquear el

private readonly object clientsLock = new object(); 
private Client[] clients = new Client[0]; 

public CreateClients(int count) {  
    lock (clientsLock) {   
    clients = new string[count]; 
    ... 
    } 
}