roscar pregunta de la prueba

Question

Recientemente tuve una pregunta de la entrevista en una prueba que fue similar a la de abajo, que no tienen mucha experiencia de desarrollo utilizando hilos por favor alguien puede ayudarme a asesorar a la forma de abordar esta cuestión ?:

public class StringQueue 
{ 
    private object _lockObject = new object(); 

    private List<string> _items = new List<string>(); 

    public bool IsEmpty() 
    { 
     lock (_lockObject) 
      return _items.Count == 0; 
    } 

    public void Enqueue(string item) 
    { 
     lock (_lockObject) 
      _items.Add(item); 
    } 

    public string Dequeue() 
    { 
     lock (_lockObject) 
     { 
      string result = _items[0]; 
      _items.RemoveAt(0); 

      return result; 
     } 
    } 
} 

¿El siguiente método es seguro con la implementación anterior y por qué?

public string DequeueOrNull() 
{ 
    if (IsEmpty()) 
     return null; 

    return Dequeue(); 
} 

Answer 1

Me parece que la respuesta es no.

Mientras que el procedimiento Empty() bloquea el objeto, se libera tan pronto como se devuelve la llamada: un hilo diferente podría llamar a DequeueOrNull() entre la llamada a IsEmpty() y Dequeue() (en ese momento el objeto está desbloqueado), eliminando así el único elemento que existía, por lo que Dequeue() no era válido en ese momento.

Una solución plausible sería colocar el bloqueo sobre ambas instrucciones en DequeueOrNull(), por lo que ningún otro hilo podría llamar a DeQueue() después de la comprobación sino antes de DeQueue().

Answer 2

No, porque el estado de _items podría cambiar entre las IsEmpty() seguras para subprocesos y las llamadas Dequeue() seguras para subprocesos.

Fix con algo como lo siguiente, que asegura que _items está bloqueado durante toda la operación:

public string DequeueOrNull() 
{ 
    lock (_lockObject) 
    { 
    if (IsEmpty()) 
     return null; 

    return Dequeue(); 
    } 
} 

Nota: dependiendo de la implementation de _lock, es posible que desee evitar de doble bloqueo del recurso por moviendo las tripas de IsEmpty() y Dequeue en funciones auxiliares separadas.

Answer 3

No es seguro para la rosca. En la línea marcada es posible que el método de quitar de la cola se llama desde otro hilo y por lo tanto, la consiguiente quitar de la cola devolver un valor incorrecto:

public string DequeueOrNull() 
{ 
    if (IsEmpty()) 
     return null; 
/// << it is possible that the Dequeue is called from another thread here. 
    return Dequeue(); 
} 

El código de seguridad de rosca sería:

public string DequeueOrNull() 
{ 
    lock(_lockObject) { 
    if (IsEmpty()) 
     return null; 
    return Dequeue(); 
    } 
}