Thread.Abort Método

Referência

Definição

Namespace:: System.Threading

Assembly:: System.Threading.Thread.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.dll

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de encerramento do thread. Geralmente, a chamada a esse método termina o thread.

Sobrecargas

Abort()	Obsoleto. Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de encerramento do thread. Geralmente, a chamada a esse método termina o thread.
Abort(Object)	Obsoleto. Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de término do thread e ao mesmo tempo fornecer informações de exceção sobre o término do thread. Geralmente, a chamada a esse método termina o thread.

Comentários

Importante

O Thread.Abort método deve ser usado com cautela. Especialmente ao chamá-lo para anular um thread diferente do thread atual, você não sabe qual código foi executado ou falhou ao ser executado quando o ThreadAbortException é lançado. Você também não pode ter certeza do estado do seu aplicativo ou de qualquer aplicativo e estado do usuário que seja responsável por preservar. Por exemplo, a chamada Thread.Abort pode impedir a execução de construtores estáticos ou o lançamento de recursos não gerenciados.

Abort()

Cuidado

Thread.Abort is not supported and throws PlatformNotSupportedException.

Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de encerramento do thread. Geralmente, a chamada a esse método termina o thread.

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

PlatformNotSupportedException

Somente .NET Core e .NET 5+: Em todos os casos.

SecurityException

O chamador não tem a permissão necessária.

ThreadStateException

O thread que está sendo anulado está suspenso no momento.

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.

Observação

Quando um thread chama Abort a si mesmo, o efeito é semelhante a gerar uma exceção; o ThreadAbortException acontece imediatamente e o resultado é previsível. No entanto, se um thread chamar Abort outro thread, a anulação interromperá qualquer código em execução. Também há uma chance de que um construtor estático possa ser anulado. Em casos raros, isso pode impedir que instâncias dessa classe sejam criadas nesse domínio de aplicativo. no .NET Framework versões 1,0 e 1,1, há uma chance de o thread ser anulado enquanto um finally bloco está em execução, caso em que o finally bloco é 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.

Observação

O thread que chama Abort pode bloquear se o thread que está sendo anulado estiver em uma região protegida de código, como um catch bloco, finally bloco ou uma região de execução restrita. Se o thread que chama Abort mantém um bloqueio que o thread anulado requer, pode ocorrer um deadlock.

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

Aplica-se a

Abort(Object)

Cuidado

Thread.Abort is not supported and throws PlatformNotSupportedException.

Gera um ThreadAbortException no thread no qual ele é invocado, para iniciar o processo de término do thread e ao mesmo tempo fornecer informações de exceção sobre o término do thread. Geralmente, a chamada a esse método termina o thread.

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

stateInfo: Object

Um objeto que contém informações específicas do aplicativo, como estado, que podem ser usadas pelo thread que está sendo anulado.

Atributos: ObsoleteAttribute

Exceções

PlatformNotSupportedException

Somente .NET Core e .NET 5+: Em todos os casos.

SecurityException

O chamador não tem a permissão necessária.

ThreadStateException

O thread que está sendo anulado está suspenso no momento.

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.

Observação

Quando um thread chama por si mesmo, o efeito é semelhante a lançar uma exceção; o ocorre imediatamente Abort e o resultado é ThreadAbortException previsível. No entanto, se um thread chamar Abort em outro thread, a anulação interromperá qualquer código em execução. Há uma chance de que um construtor estático possa ser anulado. Em casos raros, isso pode impedir que instâncias dessa classe seja criada nesse domínio de aplicativo. No .NET Framework versões 1.0 e 1.1, há uma chance de o thread ser anulado enquanto um bloco está em execução, caso em que o bloco finally finally é 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á.

Observação

O thread que chama poderá bloquear se o thread que está sendo anulado estiver em uma região protegida de código, como um bloco, bloco ou região Abort catch de execução finally restrita. Se o thread que chama Abort contém um bloqueio que o thread anulado requer, um deadlock pode ocorrer.

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

Aplica-se a

Thread.Abort Método

Definição

Sobrecargas

Comentários

Abort()

Exceções

Comentários

Confira também

Aplica-se a

Abort(Object)

Parâmetros

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais