How to abort a running thread when the windows application gets closed

Either do what Dylan already proposed (I recommend that) or you can also keep track of which Threads you started in your application and then use Thread.Abort() to kill them.

Best Regards,

This is the additional note for additional note, by Manfred. :-)

Of course you can use Thread.Abort and you should do it in some situations, but you need to do it very responsibly. In all cases you should handle ThreadAbortException exception. Strictly speaking, if this is the very end of the application run-time, you might ignore it and any related problems. I don't recommend it; it could badly hurt supportability of your code.

Think about just one thing, for example: what happens if you thread opened some files with write access and some data need flush? Handling ThreadAbortException allows you to handle all "post-mortal" situations.

For more detail, please see my discussion with Olivier over his answer to this Question: How do I abort a specific thread that is already running?[^]. Please find a sub-string "exception seeding" to get into the topic. There I tried to provide very little known information on how it works.

—SA

Thanks to everyone for early response . I done all suggested changes but no luck.

I make my thread as background thread but result is the same. Thread is still running.
I also try to kill the thread on Windows Application FormClosed() event but still no luck.

I want to share one thing that my thread is started from "User Control" so when we stop main application the "User Control" thread should also stop or not. Please suggest.

Hi,

Maybe this approach will work for you:

When writing a Windows Forms application, I tend to use the Application.ApplicationExit event as the trigger to terminate any running threads that the application needed.

How you actually terminate the thread is up to you and the design, but I generally build a kill-switch into the thread-methods's loop. Once that is set to false, the thread method terminates on it's next pass through the loop.

PS: if you have a Monitor.Wait() or AutoResetEvent.WaitOne() holding your thread suspended while it waits for work, don't forget to signal the thread when you want it to stop.

eg:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Windows.Forms;


    class ThreadTerminateExample
    {
        /// <summary>
        /// worker thread.
        /// </summary>
        private Thread _thread;

        /// <summary>
        /// control flag.
        /// </summary>
        private bool _runFlag = true;

        /// <summary>
        /// constructor.
        /// </summary>
        public ThreadTerminateExample()
        {
            _thread = new Thread((ThreadStart)ThreadMethod);
            _thread.Start();

            // handle the application exit event to stop threads on exit.
            Application.ApplicationExit += new EventHandler(Application_ApplicationExit);
        }

        /// <summary>
        /// application exit event handler
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void Application_ApplicationExit(object sender, EventArgs e)
        {
            // stop the thread.
            StopThread();
        }

        /// <summary>
        /// thread worker method.
        /// </summary>
        private void ThreadMethod()
        {
            while (_runFlag)
            {
                Console.WriteLine("Doing Some Work");
                Thread.Sleep(1000);
            }
        }

        /// <summary>
        /// stop thread method.
        /// </summary>
        private void StopThread()
        {
            _runFlag = false;
            _thread.Join(2000);
            _thread = null;
        }

    }