C#

George_George wrote:

You mean in the exception handler for ThreadAbortException, we should do clean-up things, like release the native resouce, or else there will be resource leak, right?

George_George wrote:

I am afraid others may call Thread.Abort on my thread, so I am asking how to handle properly

Le Centriste wrote:

Yes, and if your thread is also prone to block, handle the ThreadInterruptedException also.

George_George wrote:

I think if they are ensured to be called, we can rely on them to clean-up resources, and leave the body of handlers for Abort/Interrupt exceptions empty.

Guffa wrote:

A background thread calls the Finalize method of the objects, but if there are too many objects left in the queue when the application ends, the objects will just be thrown away without finalising.

Guffa wrote:

The ThreadAbortException exception exists so that you will have a chance to clean up the resources properly, so that you don't have to hope that they will eventually clean up themselves. You should clean up the resources as soon as possible, not wait for the garbage collector to initiate the cleanup.

George_George wrote:

Do you have any documents to support your points that in some situations, the finalizers can not called?

George_George wrote:

Clean-up in the handler for ThreadAbortException?

George_George wrote:

Can we rely on finally block and exception handler for ThreadAbortException?

George_George wrote:

Seems the timeout issue for Finalizer (Finalizer can not execute longer than some amount of time, as your referred article describes) only happens when AppDomain shuts down. If the AppDomain is still running, there should not be timeout issue?

George_George wrote:

Suppose I have ThreadAbortException in a worker thread, the main thread could only catch it by using AppDomain.CurrentDomain.UnhandledException?

Guffa wrote:

Yes, that would be the only way of catching an exception from outside the thread. However, I don't think that a ThreadAbortException exception will cause that event to be triggered, but I can't find any documentation right now that either confirms or contradicts this.

using System;
using System.Threading;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {

        static void ThreadProc()
        {
            Console.WriteLine("Begin sleeping ");
            Thread.Sleep(5000);
            Console.WriteLine("End sleeping ");
        }
        
        static void Foo(object sender, UnhandledExceptionEventArgs e)
        {
            Console.WriteLine("I am here ");
        }

        static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Foo);

            Thread t = new Thread(Program.ThreadProc);

            t.Start();

            t.Abort();

            return;

        }
    }
}

Guffa wrote:

but if a background thread is aborted because the application is ending, the exception will not be thrown.

George_George wrote:

I have verified you are correct. Here is my code. Could you review whether my code is correct please?

George_George wrote:

Confused. You mean the ThreadAbortException will not be re-throw if it is caught?

Guffa wrote:

No, I mean that the ThreadAbortException will not be thrown at all.

catch (Exception ex)
{
    Console.WriteLine(ex.ToString());
}

using System;
using System.Threading;
using System.IO;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {

        static void ThreadProc()
        {
            try
            {
                Console.WriteLine("Begin sleeping ");
                Thread.Sleep(5000);
                Console.WriteLine("End sleeping ");
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
        
        static void Foo(object sender, UnhandledExceptionEventArgs e)
        {
            Console.WriteLine("I am here ");
        }

        static void Main(string[] args)
        {
            AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(Foo);

            Thread t = new Thread(Program.ThreadProc);

            t.IsBackground = true;

            t.Start();

            Thread.Sleep(1000);

            t.Abort();

            Console.WriteLine("I am there ");

            return;

        }
    }
}

George_George wrote:

I do not think there is any differences dealing with Thread.Abort a background thread and a normal thread.