Thread.Interrupt Método

Definição

Espaço de Nomes:
System.Threading
Assemblagem:
mscorlib.dll
Assemblagem:
netstandard.dll

Interrompe um thread que está no WaitSleepJoin estado do thread.

public:
 void Interrupt();
public void Interrupt();
member this.Interrupt : unit -> unit
Public Sub Interrupt ()

Exceções

SecurityException

O chamador não tem o valor apropriado SecurityPermission.

Exemplos

O exemplo de código seguinte mostra o comportamento de um thread em execução quando é interrompido e, subsequentemente, bloqueado.

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

open System.Threading

type StayAwake() =
    member val SleepSwitch = false with get, set

    member this.ThreadMethod() =
        printfn "newThread is executing ThreadMethod."

        while not this.SleepSwitch do
            // Use SpinWait instead of Sleep to demonstrate the
            // effect of calling Interrupt on a running thread.
            Thread.SpinWait 10000000

        try
            printfn "newThread going to sleep."

            // When newThread goes to sleep, it is immediately
            // woken up by a ThreadInterruptedException.
            Thread.Sleep Timeout.Infinite
        with :? ThreadInterruptedException ->
            printfn "newThread cannot go to sleep - interrupted by main thread."

let stayAwake = StayAwake()
let newThread = Thread 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()
printfn "Main thread calls Interrupt on newThread."

// Tell newThread to go to sleep.
stayAwake.SleepSwitch <- true

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

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

Observações

Se este tópico não estiver atualmente bloqueado em estado de espera, suspensão ou junção, será interrompido quando começar a bloquear novamente.

ThreadInterruptedException é lançado no fio interrompido, mas só quando o fio bloqueia. Se a thread nunca bloquear, a exceção nunca é lançada, e assim a thread pode ser concluída sem nunca ser interrompida.

Aplica-se a

Ver também