Thread::Abort Method (Object^)


The .NET API Reference documentation has a new home. Visit the .NET API Browser on to see the new experience.

Raises a ThreadAbortException in the thread on which it is invoked, to begin the process of terminating the thread while also providing exception information about the thread termination. Calling this method usually terminates the thread.

Namespace:   System.Threading
Assembly:  mscorlib (in mscorlib.dll)

[SecurityPermissionAttribute(SecurityAction::Demand, ControlThread = true)]
void Abort(
	Object^ stateInfo


Type: System::Object^

An object that contains application-specific information, such as state, which can be used by the thread being aborted.

Exception Condition

The caller does not have the required permission.


The thread that is being aborted is currently suspended.

When this method is invoked on a thread, the system throws a ThreadAbortException in the thread to abort it. ThreadAbortException is a special exception that can be caught by application code, but is re-thrown at the end of the catch block unless ResetAbort is called. ResetAbort cancels the request to abort, and prevents the ThreadAbortException from terminating the thread. Unexecuted finally blocks are executed before the thread is aborted.


When a thread calls Abort on itself, the effect is similar to throwing an exception; the ThreadAbortException happens immediately, and the result is predictable. However, if one thread calls Abort on another thread, the abort interrupts whatever code is running. There is a chance that a static constructor could be aborted. In rare cases, this might prevent instances of that class from being created in that application domain. In the .NET Framework versions 1.0 and 1.1, there is a chance the thread could abort while a finally block is running, in which case the finally block is aborted.

The thread is not guaranteed to abort immediately, or at all. This situation can occur if a thread does an unbounded amount of computation in the finally blocks that are called as part of the abort procedure, thereby indefinitely delaying the abort. To wait until a thread has aborted, you can call the Join method on the thread after calling the Abort method, but there is no guarantee that the wait will end.


The thread that calls Abort might block if the thread that is being aborted is in a protected region of code, such as a catch block, finally block, or constrained execution region. If the thread that calls Abort holds a lock that the aborted thread requires, a deadlock can occur.

If Abort is called on a thread that has not been started, the thread will abort when Start is called. If Abort is called on a thread that is blocked or is sleeping, the thread is interrupted and then aborted.

If Abort is called on a thread that has been suspended, a ThreadStateException is thrown in the thread that called Abort, and AbortRequested is added to the ThreadState property of the thread being aborted. A ThreadAbortException is not thrown in the suspended thread until Resume is called.

If Abort is called on a managed thread while it is executing unmanaged code, a ThreadAbortException is not thrown until the thread returns to managed code.

If two calls to Abort come at the same time, it is possible for one call to set the state information and the other call to execute the Abort. However, an application cannot detect this situation.

After Abort is invoked on a thread, the state of the thread includes AbortRequested. After the thread has terminated as a result of a successful call to Abort, the state of the thread is changed to Stopped. With sufficient permissions, a thread that is the target of an Abort can cancel the abort using the ResetAbort method. For an example that demonstrates calling the ResetAbort method, see the ThreadAbortException class.

The following code example shows how to pass information to a thread that is being aborted.

using namespace System;
using namespace System::Threading;
ref class Test

   static void TestMethod()
         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 ) );
   Thread::Sleep( 1000 );

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

   // Wait for the thread to terminate.
   Console::WriteLine( "New thread terminated - main exiting." );


for advanced operations on threads. Associated enumeration: SecurityPermissionFlag::ControlThread.

.NET Framework
Available since 1.1
Return to top