Expected ThreadAbort for Background Thread

Question

I have the following.

public static Thread testThread = new Thread(ThreadStart) {Name = "TestThread", IsBackground = true};
private void Form_Load()
{
    testThread.Start()
}
private static void ThreadStart()
{
    int count = 0;
    try
    {
        while (true)
        {
            count++;
        }
    }
    catch (Exception ex)
    {

        StreamWriter stream = new StreamWriter(File.OpenWrite("Exception.txt"));
        stream.WriteLine(count + "\n" + ex);
        stream.Flush();
        stream.Close();
    }
}

When I call Thread.Abort() I catch the exception and write out to the file. However, if I instead close the application nothing is written. I also have

AppDomain.CurrentDomain.UnhandledException +=
   new UnhandledExceptionEventHandler(CurrentDomain_UnhandledException);
Application.SetUnhandledExceptionMode(UnhandledExceptionMode.ThrowException);
Application.ThreadException +=
   new System.Threading.ThreadExceptionEventHandler(Application_ThreadException);

But it doesn't appear an exception is ever thrown.

I suppose adding a question is prudent.

What happens to a running background thread when the parent processes exits? My understanding was a ThreadAbortException is thrown to exit the thread. If this is the case, how can the ThreadAbortException be caught in order to clean up resources that may be present in the thread?

Answer 1

First of all, the application probably isn't exiting, because you are not making these into background threads. My guess is that Task Manager will show copies of your EXE running unexpectedly. You need to set Thread.IsBackground to true on the thread object before calling Start.

Secondly, the behavior that you expect is explicitly debunked by the documentation:

Note

When the common language runtime (CLR) stops background threads, after all foreground threads in a managed executable have ended, it does not use System.Threading.Thread.Abort. Therefore, you cannot use ThreadAbortException to detect when background threads are being terminated by the CLR.

EDIT:

When a process is exiting, there is no need to clean up resources held by the worker threads because, you know, the process is exiting. The contract with regard to background threads is that they can be killed at any time when the process exits. Therefore, if your background threads are doing something that requires transactional correctness, they probably should not be background threads. Make 'em foreground threads and have them periodically check or wait on a reset event to see whether they should exit and allow the process to end.

Answer 2

When the CLR shuts down a process it does not call Thread.Abort or anything similar. Your thread methods will not exit like your main method.

1. The first thing it does when you leave the main method or call Environment.Exit is to finalize all objects with a timeout (it was 2s in .NET 2.0) then it will continue to terminate the application regardless of the current pending finalizers.
2. Next the Critical Finalizers are called.
3. Then all threads are suspended so they do not cause harm while the CLR is shutting down.
4. You application has exited.

Answer 3

If the IsBackground property of your thread is false, then your thread would remain alive, even when the main window of your application is closed.

The best way to control the lifetime of background threads is to create sentinels, typically implemented as volatile bool fields, which the code within the thread checks at regular intervals (for example, on every iteration). The thread should stop executing when the sentinel indicates that the application is terminating.

The following code shows the use of a sentinel to terminate the thread after 200 milliseconds:

public static Thread testThread = new Thread(ThreadStart) 
{
    Name = "TestThread", 
    IsBackground = false    // Allow thread to terminate naturally
};

private static volatile bool isTerminating = false;   // Sentinel

private void Form_Load()
{
    testThread.Start();
    Thread.Sleep(200);      // Sleep 200 milliseconds
    isTerminating = true;   // Set sentinel to terminate thread
}

private static void ThreadStart()
{
    int count = 0;

    while (!isTerminating)   // Keep looping until sentinel is set
        count++;

    using (StreamWriter stream = new StreamWriter(File.OpenWrite("Result.txt")))
    {
        stream.WriteLine(count);
        stream.Flush();
    }
}

Edit: To answer your last question, “How can the ThreadAbortException be caught in order to clean up resources that may be present in the thread?” You can use an ordinary catch block. ThreadAbortException may be caught like any other exception, but it will automatically be raised again at the end of the catch block. However, as Chris mentioned, if the process is exiting, the ThreadAbortException is not raised at all.