¿Qué sucede si saltas de una instrucción Lock()?

Question

Estoy escribiendo un programa que escucha un TcpClient entrante y maneja los datos cuando llegan. El método Listen() se ejecuta en un subproceso separado dentro del componente, por lo que debe ser seguro para la ejecución de subprocesos. Si yo break fuera de un dowhile loop mientras estoy dentro de una declaración lock(), ¿se liberará el bloqueo? Si no, ¿cómo lo logro?

Gracias!

(Cualquier otro tipo de asesoramiento sobre el tema de asincrónicos sockets TCP es bienvenido también.)

private void Listen() 
{ 
    do 
    { 
     lock (_clientLock) 
     { 
      if (!_client.Connected) break; 
      lock (_stateLock) 
      { 
       if (!_listening) break; 
       if (_client.GetStream().DataAvailable) HandleData(); 
      } 
     } 
     Thread.Sleep(0); 
    } while (true); 
} 

Answer 1

Sí. La instrucción de bloqueo se traduce en una cláusula try/finally. En C# 4, por ejemplo, una declaración de bloqueo de este modo:

lock(obj) 
{ 
    // body 
} 

podría traducir (taken from Eric Lippert's blog here) a:

bool lockWasTaken = false; 
var temp = obj; 
try 
{ 
    Monitor.Enter(temp, ref lockWasTaken); 
    { 
     // body 
    } 
} 
finally 
{ 
    if (lockWasTaken) 
     Monitor.Exit(temp); 
} 

Cuando la ejecución deja al alcance de la lock {}, se dará a conocer el cerrojo subyacente automáticamente. Esto sucederá sin importar cómo salga del alcance (break/return/etc), ya que la llamada a Monitor.Exit está envuelta, internamente, dentro del bloque finally de try/finally.

Answer 2

vez que salga del lock{}, se desbloqueará lo que ha bloqueado (que es igual que una instrucción using en ese considerar). No importa dónde salgas (el comienzo, el final o el medio), es que dejaste el alcance de la cerradura. Piensa en lo que sucedería si plantearas una excepción en el medio.

Answer 3

Sí, se desbloqueará la cerradura. Puede usar ILDASM o Reflector para mirar el código generado real. La instrucción de bloqueo es una abreviatura del siguiente código (aproximadamente).

Monitor.Enter(_client); 
try 
{ 
    // do your stuff 

} 
finally { 
    Monitor.Exit(_client); 
} 

Observe que el bloque finally siempre se ejecuta.

Answer 4

Porque me pidió otro consejo ... Noté que está anidando cerraduras. Esto, en sí mismo, no es necesariamente algo malo. Pero, es una de mis banderas rojas que cuido. Existe la posibilidad de un punto muerto si alguna vez adquiere esos dos bloqueos en un orden diferente en otra parte de su código. No digo que haya ningún problema con tu código. Es simplemente algo más a tener en cuenta porque es fácil equivocarse.

Answer 5

Para responder a la otra mitad de su pregunta:

Cualquier otro tipo de asesoramiento sobre el tema de asincrónicos de sockets TCP es bienvenida, así

En pocas palabras no me gestionar este a la moda demostrado por tu publicación original. Más bien busque ayuda de las clases System.Net.Sockets.TcpClient y System.Net.Sockets.TcpListener. Use las llamadas asincrónicas como BeginAcceptSocket (...) y BeginRead (...) y permita que ThreadPool haga su trabajo. Es realmente fácil de armar de esa manera.

Usted debe ser capaz de lograr todo el comportamiento del servidor que desee sin tener que codificar las temidas palabras "nuevo hilo" :)

Aquí es un ejemplo básico de la idea, menos la idea de apagado correcto, manejo de excepciones ect:

public static void Main() 
{ 
    TcpListener listener = new TcpListener(new IPEndPoint(IPAddress.Loopback, 8080)); 
    listener.Start(); 
    listener.BeginAcceptTcpClient(OnConnect, listener); 

    Console.WriteLine("Press any key to quit..."); 
    Console.ReadKey(); 
} 

static void OnConnect(IAsyncResult ar) 
{ 
    TcpListener listener = (TcpListener)ar.AsyncState; 
    new TcpReader(listener.EndAcceptTcpClient(ar)); 
    listener.BeginAcceptTcpClient(OnConnect, listener); 
} 

class TcpReader 
{ 
    string respose = "HTTP 1.1 200\r\nContent-Length:12\r\n\r\nHello World!"; 
    TcpClient client; 
    NetworkStream socket; 
    byte[] buffer; 

    public TcpReader(TcpClient client) 
    { 
     this.client = client; 
     socket = client.GetStream(); 

     buffer = new byte[1024]; 
     socket.BeginRead(buffer, 0, 1024, OnRead, socket); 
    } 

    void OnRead(IAsyncResult ar) 
    { 
     int nBytes = socket.EndRead(ar); 
     if (nBytes > 0) 
     { 
      //you have data... do something with it, http example 
      socket.BeginWrite(
       Encoding.ASCII.GetBytes(respose), 0, respose.Length, null, null); 

      socket.BeginRead(buffer, 0, 1024, OnRead, socket); 
     } 
     else 
      socket.Close(); 
    } 
} 

para un ejemplo mucho más complicada de cómo hacerlo, vea la SslTunnel Library que escribí hace un tiempo.