Esta documentación está archivada y no tiene mantenimiento.

ThreadInterruptedException (Clase)

Excepción que se produce cuando Thread se interrumpe mientras se encuentra en estado de espera.

Espacio de nombres: System.Threading
Ensamblado: mscorlib (en mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public class ThreadInterruptedException : SystemException
/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public class ThreadInterruptedException extends SystemException
SerializableAttribute 
ComVisibleAttribute(true) 
public class ThreadInterruptedException extends SystemException
No aplicable.

Una vez que se crea un subproceso, éste se encuentra siempre en uno o más estados ThreadState hasta que se destruye. Si se llama a Interrupt mientras un subproceso se encuentra en estado WaitSleepJoin se producirá ThreadInterruptedException en el subproceso de destino. Si el subproceso no está en el estado WaitSleepJoin, no se produce la excepción hasta que el subproceso entre en ese estado. Si el subproceso nunca se bloquea, puede completarse sin ninguna interrupción.

ThreadInterruptedException utiliza el resultado HRESULT COR_E_THREADINTERRUPTED, que tiene el valor 0x80131519.

Para obtener una lista con los valores de propiedad iniciales de una instancia de ThreadInterruptedException, vea los constructores ThreadInterruptedException.

En el ejemplo de código siguiente se muestra el comportamiento de un subproceso en ejecución que se interrumpe y queda posteriormente bloqueado.

using System;
using System.Security.Permissions;
using System.Threading;

[assembly: SecurityPermissionAttribute(SecurityAction.RequestMinimum,
    ControlThread = true)]

class ThreadInterrupt
{
    static void Main()
    {
        StayAwake stayAwake = new StayAwake();
        Thread newThread = 
            new Thread(new ThreadStart(stayAwake.ThreadMethod));
        newThread.Start();

        // The following line causes an exception to be thrown 
        // in ThreadMethod if newThread is currently blocked
        // or becomes blocked in the future.
        newThread.Interrupt();
        Console.WriteLine("Main thread calls Interrupt on newThread.");

        // Tell newThread to go to sleep.
        stayAwake.SleepSwitch = true;

        // Wait for newThread to end.
        newThread.Join();
    }
}

class StayAwake
{
    bool sleepSwitch = false;

    public bool SleepSwitch
    {
        set{ sleepSwitch = value; }
    }

    public StayAwake(){}

    public void ThreadMethod()
    {
        Console.WriteLine("newThread is executing ThreadMethod.");
        while(!sleepSwitch)
        {
            // Use SpinWait instead of Sleep to demonstrate the 
            // effect of calling Interrupt on a running thread.
            Thread.SpinWait(10000000);
        }
        try
        {
            Console.WriteLine("newThread going to sleep.");

            // When newThread goes to sleep, it is immediately 
            // woken up by a ThreadInterruptedException.
            Thread.Sleep(Timeout.Infinite);
        }
        catch(ThreadInterruptedException e)
        {
            Console.WriteLine("newThread cannot go to sleep - " +
                "interrupted by main thread.");
        }
    }
}

import System.*;
import System.Security.Permissions.*;
import System.Threading.*;
import System.Threading.Thread;

/** @assembly SecurityPermissionAttribute(SecurityAction.RequestMinimum,
    ControlThread = true)
 */

class ThreadInterrupt
{
    public static void main(String[] args)
    {
        StayAwake stayAwake =  new StayAwake();
        Thread newThread =  new Thread(new ThreadStart(stayAwake.ThreadMethod));
        newThread.Start();
      
        // The following line causes an exception to be thrown 
        // in ThreadMethod if newThread is currently blocked
        // or becomes blocked in the future.
        newThread.Interrupt();
        Console.WriteLine("Main thread calls Interrupt on newThread.");
      
        // Tell newThread to go to sleep.
        stayAwake.set_SleepSwitch(true);
      
        // Wait for newThread to end.
        newThread.Join();
   } //main
} //ThredInterrupt

class StayAwake
{
    private boolean sleepSwitch = false;

    /** @property
     */
    public void set_SleepSwitch(boolean value)
    {
        sleepSwitch = value;
    } //set_SleepSwitch

    public StayAwake()
    {
    } //StayAwake

    public void ThreadMethod()
    {
        Console.WriteLine("newThread is executing ThreadMethod.");
        while (!(sleepSwitch)) {
            // Use SpinWait instead of Sleep to demonstrate the 
            // effect of calling Interrupt on a running thread.
            Thread.SpinWait(10000000);
        }

        try {
            Console.WriteLine("newThread going to sleep.");

            // When newThread goes to sleep, it is immediately 
            // woken up by a ThreadInterruptedException.
            Thread.Sleep(Timeout.Infinite);
        }
        catch (ThreadInterruptedException e) {
            Console.WriteLine(("newThread cannot go to sleep - " 
                + "nterrupted by main thread."));
        }
    } //ThreadMethod
} //StayAwake

System.Object
   System.Exception
     System.SystemException
      System.Threading.ThreadInterruptedException

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Windows 98, Windows 2000 Service Pack 4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter

Microsoft .NET Framework 3.0 es compatible con Windows Vista, Microsoft Windows XP SP2 y Windows Server 2003 SP1.

.NET Framework

Compatible con: 3.0, 2.0, 1.1, 1.0
Mostrar: