Thread.Abort Método

public:
 void Abort();

[System.Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId="SYSLIB0006", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public void Abort ();

public void Abort ();

[<System.Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId="SYSLIB0006", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
member this.Abort : unit -> unit

member this.Abort : unit -> unit

Public Sub Abort ()

Atributos

ObsoleteAttribute

Exceções

Comentários

Esse método é obsoleto. No .NET 5 e versões posteriores, chamar esse método produz um aviso de tempo de compilação. Esse método gera um PlatformNotSupportedException em tempo de execução no .NET 5 e posterior e no .NET Core.

Quando esse método é invocado em um thread, o sistema gera um ThreadAbortException no thread para abortar. ThreadAbortException é uma exceção especial que pode ser detectada pelo código do aplicativo, mas é relançada no final do catch bloco, a menos que ResetAbort seja chamado. ResetAbort Cancela a solicitação para abortar e impede que o ThreadAbortException encerre o thread. finallyBlocos não executados são executados antes de o thread ser anulado.

Não há garantia de que o thread seja anulado imediatamente ou de nenhuma. Essa situação pode ocorrer se um thread fizer uma quantidade não associada de computação nos finally blocos que são chamados como parte do procedimento de anulação, indefinidamente atrasando a anulação. Para aguardar até que um thread seja anulado, você pode chamar o Join método no thread depois de chamar o Abort método, mas não há nenhuma garantia de que a espera será encerrada.

Se Abort for chamado em um thread que não foi iniciado, o thread será anulado quando Start for chamado. Se Abort for chamado em um thread bloqueado ou estiver em suspensão, o thread será interrompido e anulado.

Se Abort for chamado em um thread que foi suspenso, um ThreadStateException será lançado no thread que chamou Abort e AbortRequested será adicionado à ThreadState Propriedade do thread que está sendo anulado. Um ThreadAbortException não é lançado no thread suspenso até que Resume seja chamado.

Se Abort for chamado em um thread gerenciado enquanto está executando código não gerenciado, um ThreadAbortException não será lançado até que o thread retorne para o código gerenciado.

Se duas chamadas Abort chegarem ao mesmo tempo, é possível que uma chamada defina as informações de estado e a outra chamada para executar o Abort . No entanto, um aplicativo não pode detectar essa situação.

Depois Abort que é invocado em um thread, o estado do thread inclui AbortRequested . Depois que o thread for encerrado como resultado de uma chamada bem-sucedida para Abort , o estado do thread será alterado para Stopped . Com permissões suficientes, um thread que é o destino de um Abort pode cancelar a anulação usando o ResetAbort método. Para obter um exemplo que demonstra a chamada do ResetAbort método, consulte a ThreadAbortException classe.

Confira também

• ThreadAbortException
• Aborted
• AbortRequested
• Threads e threading
• Usando threads e threading
• Destruindo threads

public:
 void Abort(System::Object ^ stateInfo);

[System.Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId="SYSLIB0006", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
public void Abort (object? stateInfo);

public void Abort (object stateInfo);

public void Abort (object? stateInfo);

[<System.Obsolete("Thread.Abort is not supported and throws PlatformNotSupportedException.", DiagnosticId="SYSLIB0006", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
member this.Abort : obj -> unit

member this.Abort : obj -> unit

Public Sub Abort (stateInfo As Object)

Parâmetros

Atributos

ObsoleteAttribute

Exceções

Exemplos

O exemplo de código a seguir mostra como passar informações para um thread que está sendo anulado.

using namespace System;
using namespace System::Threading;
ref class Test
{
private:
   Test(){}


public:
   static void TestMethod()
   {
      try
      {
         while ( true )
         {
            Console::WriteLine( "New thread running." );
            Thread::Sleep( 1000 );
         }
      }
      catch ( ThreadAbortException^ abortException ) 
      {
         Console::WriteLine( dynamic_cast<String^>(abortException->ExceptionState) );
      }

   }

};

int main()
{
   Thread^ newThread = gcnew Thread( gcnew ThreadStart( &Test::TestMethod ) );
   newThread->Start();
   Thread::Sleep( 1000 );
   
   // Abort newThread.
   Console::WriteLine( "Main aborting new thread." );
   newThread->Abort( "Information from main." );
   
   // Wait for the thread to terminate.
   newThread->Join();
   Console::WriteLine( "New thread terminated - main exiting." );
}

using System;
using System.Threading;

class Test
{
    public static void Main()
    {
        Thread newThread  = new Thread(new ThreadStart(TestMethod));
        newThread.Start();
        Thread.Sleep(1000);

        // Abort newThread.
        Console.WriteLine("Main aborting new thread.");
        newThread.Abort("Information from Main.");

        // Wait for the thread to terminate.
        newThread.Join();
        Console.WriteLine("New thread terminated - Main exiting.");
    }

    static void TestMethod()
    {
        try
        {
            while(true)
            {
                Console.WriteLine("New thread running.");
                Thread.Sleep(1000);
            }
        }
        catch(ThreadAbortException abortException)
        {
            Console.WriteLine((string)abortException.ExceptionState);
        }
    }
}

Imports System.Threading

Public Class Test

    <MTAThread> _
    Shared Sub Main()
        Dim newThread As New Thread(AddressOf TestMethod)
        newThread.Start()
        Thread.Sleep(1000)

        ' Abort newThread.
        Console.WriteLine("Main aborting new thread.")
        newThread.Abort("Information from Main.")

        ' Wait for the thread to terminate.
        newThread.Join()
        Console.WriteLine("New thread terminated - Main exiting.")
    End Sub

    Shared Sub TestMethod()
        Try
            While True
                Console.WriteLine("New thread running.")
                Thread.Sleep(1000)
            End While
        Catch abortException As ThreadAbortException
            Console.WriteLine( _
                CType(abortException.ExceptionState, String))
        End Try
    End Sub

End Class

Comentários

Esse método é obsoleto. No .NET 5 e versões posteriores, chamar esse método produz um aviso de tempo de compilação. Esse método lança um PlatformNotSupportedException em tempo de operação no .NET 5 e posterior e no .NET Core.

Quando esse método é invocado em um thread, o sistema lança ThreadAbortException um no thread para anuá-lo. ThreadAbortException é uma exceção especial que pode ser capturada pelo código do aplicativo, mas é lançada no final do bloco, a menos que catch ResetAbort seja chamado. ResetAbort cancela a solicitação de anulação e impede o ThreadAbortException de encerrar o thread. Blocos não finally cortados são executados antes que o thread seja anulado.

Não há garantia de que o thread seja anulado imediatamente ou de forma alguma. Essa situação poderá ocorrer se um thread fizer uma quantidade de computação não unidas nos blocos que são chamados como parte do procedimento de anulação, atrasando indefinidamente a finally anulação. Para aguardar até que um thread seja anulado, você pode chamar o método no thread depois de chamar o método , mas não há nenhuma garantia de que a Join Abort espera terminará.

Se Abort for chamado em um thread que não foi iniciado, o thread será anulado quando for Start chamado. Se Abort for chamado em um thread que está bloqueado ou está suspenso, o thread é interrompido e anulado.

Se for chamado em um thread que foi suspenso, um será lançado no thread que chamou e será adicionado à propriedade do Abort thread que está sendo ThreadStateException Abort AbortRequested ThreadState anulado. Um ThreadAbortException não é lançado no thread suspenso até que seja Resume chamado.

Se for chamado em um thread gerenciado enquanto estiver executando código não gerenciado, um não será lançado até que Abort o thread retorne ao código ThreadAbortException gerenciado.

Se duas chamadas aparecerem ao mesmo tempo, será possível que uma chamada de de definir as informações de estado e a outra Abort chamada execute o Abort . No entanto, um aplicativo não pode detectar essa situação.

Depois Abort que é invocado em um thread, o estado do thread inclui AbortRequested . Depois que o thread for encerrado como resultado de uma chamada bem-sucedida para Abort , o estado do thread será alterado para Stopped . Com permissões suficientes, um thread que é o destino de um pode cancelar a Abort anulação usando o ResetAbort método . Para ver um exemplo que demonstra como chamar ResetAbort o método , consulte a classe ThreadAbortException .

Confira também

• ThreadAbortException
• Aborted
• AbortRequested
• Threads e threading
• Usando threads e threading
• Destruindo threads