Killing a .NET thread

Do not call Thread.Abort()!

Thread.Abort is dangerous. Instead you should cooperate with the thread so that it can be peacefully shut down. The thread needs to be designed so that it can be told to kill itself, for instance by having a boolean keepGoing flag that you set to false when you want the thread to stop. The thread would then have something like

while (keepGoing){    /* Do work. */}

If the thread may block in a Sleep or Wait then you can break it out of those functions by calling Thread.Interrupt(). The thread should then be prepared to handle a ThreadInterruptedException:

try{    while (keepGoing)    {        /* Do work. */    }}catch (ThreadInterruptedException exception){    /* Clean up. */}

You should really only call Abort() as a last resort. You can use a variable to sync this thread instead:

volatile bool shutdown = false;void RunThread(){   while (!shutdown)   {      ...   }}void StopThread(){   shutdown = true;}

This allows your thread to cleanly finish what it was doing, leaving your app in a known good state.

The most correct and thread-safe way is to use a WaitHandle to signal to the thread when it's supposed to stop. I mostly use ManualResetEvent.

In your thread, you can have:

private void RunThread(){    while(!this.flag.WaitOne(TimeSpan.FromMilliseconds(100)))    {        // ...    }}

where this.flag is an instance of ManualResetEvent. This means that you can call this.flag.Set() from outside the thread to stop the loop.

The WaitOne method will only return true when the flag is set. Otherwise, it will time out after the specified timeout (100 ms in the example) and the thread will run through the loop once more.