ThreadInterruptedException Klasse

Referenz

Definition

Namespace:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Die Ausnahme, die ausgelöst wird, wenn ein Thread im Wartezustand unterbrochen wird.

public ref class ThreadInterruptedException : SystemException

public class ThreadInterruptedException : SystemException

[System.Serializable]
public class ThreadInterruptedException : SystemException

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ThreadInterruptedException : SystemException

type ThreadInterruptedException = class
    inherit SystemException

[<System.Serializable>]
type ThreadInterruptedException = class
    inherit SystemException

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ThreadInterruptedException = class
    inherit SystemException

Public Class ThreadInterruptedException
Inherits SystemException

Vererbung: Object

Exception

SystemException
ThreadInterruptedException

Attribute: SerializableAttribute ComVisibleAttribute

Beispiele

Das folgende Codebeispiel zeigt das Verhalten eines ausgeführten Threads, wenn es unterbrochen wird und anschließend blockiert wird.

using namespace System;
using namespace System::Security::Permissions;
using namespace System::Threading;

ref class StayAwake
{
private:
   bool sleepSwitch;

public:

   property bool SleepSwitch 
   {
      void set( bool value )
      {
         sleepSwitch = value;
      }

   }
   StayAwake()
   {
      sleepSwitch = false;
   }

   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." );
      }

   }

};

int main()
{
   StayAwake^ stayAwake = gcnew StayAwake;
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( stayAwake, &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." );
   
   // Then tell newThread to go to sleep.
   stayAwake->SleepSwitch = true;
   
   // Wait for newThread to end.
   newThread->Join();
}

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

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.");
        }
    }
}

Option Explicit
Option Strict

Imports System.Security.Permissions
Imports System.Threading

Public Class ThreadInterrupt

    <MTAThread> _
    Shared Sub Main()
        Dim stayAwake As New StayAwake()
        Dim newThread As New Thread(AddressOf 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()
    End Sub

End Class

Public Class StayAwake

    Dim sleepSwitchValue As Boolean = False

    WriteOnly Property SleepSwitch As Boolean
        Set
            sleepSwitchValue = Value
        End Set
    End Property 

    Sub New()
    End Sub

    Sub ThreadMethod()
        Console.WriteLine("newThread is executing ThreadMethod.")
        While Not sleepSwitchValue

            ' Use SpinWait instead of Sleep to demonstrate the 
            ' effect of calling Interrupt on a running thread.
            Thread.SpinWait(10000000)
        End While
        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 ex As ThreadInterruptedException
            Console.WriteLine("newThread cannot go to " & _
                "sleep - interrupted by main thread.")
        End Try
    End Sub

End Class

Hinweise

Nachdem ein Thread erstellt wurde, befindet es sich in einem oder ThreadState mehreren Zuständen, bis er zerstört wird. Das Aufrufen Interrupt , wenn sich ein Thread im WaitSleepJoin Zustand befindet, führt dazu, dass ein ThreadInterruptedException Thread im Zielthread ausgelöst wird. Wenn sich der Thread nicht im WaitSleepJoin Zustand befindet, wird die Ausnahme erst ausgelöst, wenn der Thread diesen Zustand eingibt. Wenn der Thread nie blockiert wird, kann er ohne jegliche Unterbrechung abgeschlossen werden.

ThreadInterruptedException verwendet die HRESULT-COR_E_THREADINTERRUPTED, die den Wert 0x80131519 hat.

Eine Liste der anfänglichen Eigenschaftswerte für eine Instanz von ThreadInterruptedException, finden Sie unter den ThreadInterruptedException Konstruktoren.

Konstruktoren

ThreadInterruptedException()	Initialisiert eine neue Instanz der ThreadInterruptedException-Klasse mit Standardeigenschaften.
ThreadInterruptedException(SerializationInfo, StreamingContext)	Initialisiert eine neue Instanz der ThreadInterruptedException-Klasse mit serialisierten Daten.
ThreadInterruptedException(String)	Initialisiert eine neue Instanz der ThreadInterruptedException-Klasse mit einer angegebenen Fehlermeldung.
ThreadInterruptedException(String, Exception)	Initialisiert eine neue Instanz der ThreadInterruptedException-Klasse mit einer angegebenen Fehlermeldung und einem Verweis auf die innere Ausnahme, die diese Ausnahme ausgelöst hat.

Eigenschaften

Data	Ruft eine Auflistung von Schlüssel-Wert-Paaren ab, die zusätzliche benutzerdefinierte Informationen zur Ausnahme bereitstellen. (Geerbt von Exception)
HelpLink	Ruft einen Link zur Hilfedatei ab, die dieser Ausnahme zugeordnet ist, oder legt einen Link fest. (Geerbt von Exception)
HResult	Ruft HRESULT ab oder legt HRESULT fest. Dies ist ein codierter Wert, der einer bestimmten Ausnahme zugeordnet ist. (Geerbt von Exception)
InnerException	Ruft die Exception-Instanz ab, die die aktuelle Ausnahme verursacht hat. (Geerbt von Exception)
Message	Ruft eine Meldung ab, mit der die aktuelle Ausnahme beschrieben wird. (Geerbt von Exception)
Source	Gibt den Namen der Anwendung oder des Objekts zurück, die bzw. das den Fehler verursacht hat, oder legt diesen fest. (Geerbt von Exception)
StackTrace	Ruft eine Zeichenfolgendarstellung der unmittelbaren Frames in der Aufrufliste ab. (Geerbt von Exception)
TargetSite	Ruft die Methode ab, die die aktuelle Ausnahme auslöst. (Geerbt von Exception)

Methoden

Equals(Object)	Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist. (Geerbt von Object)
GetBaseException()	Gibt beim Überschreiben in einer abgeleiteten Klasse eine Exception zurück, die die Grundursache für eine oder mehrere nachfolgende Ausnahmen ist. (Geerbt von Exception)
GetHashCode()	Fungiert als Standardhashfunktion. (Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)	Legt beim Überschreiben in einer abgeleiteten Klasse die SerializationInfo mit Informationen über die Ausnahme fest. (Geerbt von Exception)
GetType()	Ruft den Laufzeittyp der aktuellen Instanz ab. (Geerbt von Exception)
MemberwiseClone()	Erstellt eine flache Kopie des aktuellen Object. (Geerbt von Object)
ToString()	Erstellt eine Zeichenfolgendarstellung der aktuellen Ausnahme und gibt diese zurück. (Geerbt von Exception)

Ereignisse

SerializeObjectState

Veraltet.

Tritt auf, wenn eine Ausnahme serialisiert wird, um ein Ausnahmezustandsobjekt mit serialisierten Daten über die Ausnahme zu erstellen.

(Geerbt von Exception)

Gilt für

Produkt	Versionen
.NET	Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7
.NET Framework	1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8
.NET Standard	2.0, 2.1

Freigeben über