Todo el mundo sabe que en C #, podemos usar el método Thread.Start para iniciar un subproceso. Cuando queremos detener el subproceso en ejecución, podemos usar el método Thread.Abort para detener forzosamente el subproceso en ejecución, pero tenga en cuenta que está seguro para llamar a Thread ¿El hilo se detiene inmediatamente después del método .Abort? ¡La respuesta es no!
Expliquemos cómo funciona el método Abort. Debido a que Common Language Runtime administra todos los subprocesos administrados, también puede generar excepciones en cada subproceso. El método Abort puede lanzar una ThreadAbortException en el hilo de destino y provocar la terminación del hilo de destino. Sin embargo, después de llamar al método Abort, es posible que el hilo de destino no finalice inmediatamente. Porque mientras el hilo de destino llame a código no administrado y no haya regresado, el hilo no terminará inmediatamente. Y si el hilo de destino llama a código no administrado y cae en un bucle infinito, el hilo de destino no terminará en absoluto. Sin embargo, esta situación es solo un caso especial. Más a menudo, el hilo de destino llama al código administrado. Una vez que se llama a Abort, el hilo se termina inmediatamente.
De hecho, cuando un hilo se está ejecutando, podemos leer su estado a través de la propiedad Thread.ThreadState, y el estado del hilo en ejecución es ThreadState.Running. Luego, si queremos detener a la fuerza el subproceso en ejecución, llamaremos al método Thread.Abort, pero lo que hace el método Thread.Abort es lanzar una excepción ThreadAbortException en el subproceso y luego establecer el estado del subproceso en ThreadState.AbortRequested, MSDN The La explicación para el estado AbortRequested es: se ha llamado al método Thread.Abort en el hilo, pero el hilo aún no ha recibido la excepción System.Threading.ThreadAbortException pendiente que intenta terminarlo , lo que significa que el hilo está en ThreadState.AbortRequested estado, lo que indica que está a punto de terminar, pero aún no hay un final real. Pero el método Thread.Abort establece el estado del hilo en ThreadState.AbortRequested y regresa inmediatamente, y el estado después de que el hilo realmente termina debería ser ThreadState.Aborted, así que asegúrese de recordar verificar el bucle después de llamar al método Thread.Abort El valor de la propiedad Thread.ThreadState o llame al método Thread.Join para asegurarse de que el subproceso terminado realmente se detuvo. Solo cuando la propiedad Thread.ThreadState se cancela o el método Thread.Join regresa, significa que el subproceso realmente ha terminado.
A continuación, escribiré un código de muestra para ilustrar cómo garantizar que el código continúe ejecutándose después de que el hilo se detenga después de llamar al método Thread.Abort
var thread = new Thread (
new ThreadStart (
() =>
{
while (true)
{
// El hilo se repetirá infinitamente y no terminará por sí mismo
Thread.Sleep (100);
}
}));
thread.IsBackground = true;
thread.Start (); // Iniciar el hilo
thread.Abort (); // Llamar al método Thread.Abort para intentar terminar el hilo por la fuerza
// El hilo del hilo no puede terminarse inmediatamente después de llamar al método Thread.Abort anterior, así que estamos aquí. Aquí hay un bucle para comprobar si el hilo realmente se ha detenido. De hecho, también puede usar el método Thread.Join aquí para esperar a que termine el hilo. El método Thread.Join hace lo mismo que el efecto de bucle que escribimos aquí, bloqueando el hilo principal hasta que el hilo finaliza
while (thread .ThreadState! = ThreadState.Aborted)
{ saltamos
// Cuando se llama al método Abort, si el estado del hilo del hilo no es Abortado, el hilo principal continuará en bucle aquí hasta que el estado del hilo del hilo se vuelva Abortado
Thread.Sleep (100);
}
// Cuando salimos del ciclo anterior, significa que el hilo que comenzamos ha terminado por completo