Destrucción de subprocesosDestroying threads

El método Thread.Abort se utiliza para detener un subproceso administrado de forma permanente.The Thread.Abort method is used to stop a managed thread permanently. Cuando se llama a Abort, Common Language Runtime produce una clase ThreadAbortException en el subproceso de destino, que este último puede detectar.When you call Abort, the common language runtime throws a ThreadAbortException in the target thread, which the target thread can catch. Para más información, consulte Thread.Abort.For more information, see Thread.Abort.

Nota

Si un subproceso ejecuta código no administrado al llamar a su método Abort, el tiempo de ejecución lo marca como ThreadState.AbortRequested.If a thread is executing unmanaged code when its Abort method is called, the runtime marks it ThreadState.AbortRequested. La excepción se produce cuando el subproceso vuelve al código administrado.The exception is thrown when the thread returns to managed code.

Una vez que se anula un subproceso, no se puede reiniciar.Once a thread is aborted, it cannot be restarted.

El método Abort no hace que el subproceso se anule inmediatamente, porque el subproceso de destino puede detectar ThreadAbortException y ejecutar cantidades arbitrarias de código en un bloque finally.The Abort method does not cause the thread to abort immediately, because the target thread can catch the ThreadAbortException and execute arbitrary amounts of code in a finally block. Puede llamar a Thread.Join si tiene que esperar hasta que haya finalizado el subproceso.You can call Thread.Join if you need to wait until the thread has ended. Thread.Join es una llamada de bloqueo que no realiza ninguna devolución hasta que el subproceso se haya dejado de ejecutar realmente o hasta que haya transcurrido un intervalo de tiempo de espera opcional.Thread.Join is a blocking call that does not return until the thread has actually stopped executing or an optional timeout interval has elapsed. El subproceso anulado podría llamar al método ResetAbort o llevar a cabo el procesamiento sin enlazar en un bloqueo finally, por lo que si no especifica un tiempo de espera, no se garantiza que la espera finalice.The aborted thread could call the ResetAbort method or perform unbounded processing in a finally block, so if you do not specify a timeout, the wait is not guaranteed to end.

Los subprocesos que esperan una llamada al método Thread.Join pueden interrumpirse con otros subprocesos que llaman a Thread.Interrupt.Threads that are waiting on a call to the Thread.Join method can be interrupted by other threads that call Thread.Interrupt.

Control de ThreadAbortExceptionHandling ThreadAbortException

Si espera que se anule el subproceso, como resultado de una llamada a Abort desde su propio código o como resultado de la descarga de un dominio de aplicación en que se ejecuta el subproceso (AppDomain.Unload usa Thread.Abort para terminar los subprocesos), el subproceso debe controlar ThreadAbortException y realizar cualquier procesamiento final en una cláusula finally, como se muestra en el código siguiente.If you expect your thread to be aborted, either as a result of calling Abort from your own code or as a result of unloading an application domain in which the thread is running (AppDomain.Unload uses Thread.Abort to terminate threads), your thread must handle the ThreadAbortException and perform any final processing in a finally clause, as shown in the following code.

Try  
    ' Code that is executing when the thread is aborted.  
Catch ex As ThreadAbortException  
    ' Clean-up code can go here.  
    ' If there is no Finally clause, ThreadAbortException is  
    ' re-thrown by the system at the end of the Catch clause.   
Finally  
    ' Clean-up code can go here.  
End Try  
' Do not put clean-up code here, because the exception   
' is rethrown at the end of the Finally clause.  
try   
{  
    // Code that is executing when the thread is aborted.  
}   
catch (ThreadAbortException ex)   
{  
    // Clean-up code can go here.  
    // If there is no Finally clause, ThreadAbortException is  
    // re-thrown by the system at the end of the Catch clause.   
}  
// Do not put clean-up code here, because the exception   
// is rethrown at the end of the Finally clause.  

El código de limpieza debe estar en la cláusula catch o en la cláusula finally, porque el sistema vuelve a generar ThreadAbortException al final de la cláusula finally o al final de la cláusula catch si no existe la cláusula finally.Your clean-up code must be in the catch clause or the finally clause, because a ThreadAbortException is rethrown by the system at the end of the finally clause, or at the end of the catch clause if there is no finally clause.

Puede impedir que el sistema vuelva a generar la excepción mediante una llamada al método Thread.ResetAbort.You can prevent the system from rethrowing the exception by calling the Thread.ResetAbort method. Sin embargo, debe hacerlo solo si su propio código generó ThreadAbortException.However, you should do this only if your own code caused the ThreadAbortException.

Vea tambiénSee also