C# killing a thread

Question

Hi guys,

In my app, I have a thread that runs continuously. By using Thread.Sleep(), the function executes every 10 minutes.

I need to be able to kill this thread when a user clicks a button. I know Thread.Abort() is not reliable. I can use a variable to stop the thread, but since it is sleeping it could be another 10 minutes before the thread kills itself.

Any ideas?

Answer 1

Why don't you use a timer to schedule the task every ten minutes instead. That will run your code on a thread pool thread and thus you will not have to manage this yourself.

For more details see the System.Threading.Timer class.

Answer 2

Instead of Thread.Sleep use a System.Threading.ManualResetEvent. The WaitOne method has a timeout just like Thread.Sleep, your thread will sleep for that interval unless the event is triggered first, and the return value tells you whether the interval elapsed or the event was set.

Answer 3

One possibility is to not have it sleep for ten minutes. Have it sleep for 10 seconds then only do its work on every sixtieth wakeup. Then you only have a latency of ten seconds before it stops.

Aside: This is not necessarily the best solution but it's probably the quickest to implement. As with all possibilities you should do a cost/benefit analysis when selecting which solution is right for you.

If ten seconds is still too much, you can drop it further although keep in mind that dropping it too far will result in a possible performance impact.

You're right that you shouldn't kill threads from outside, it's usually a recipe for disaster if you happen to do it while they have a lock on some resource that's not freed on kill. Threads should always be responsible for their own resources, including their lifetimes.

Answer 4

Building on Ben's answer, here's the pattern to help you out...

using System.Threading;

public class MyWorker {
        private ManualResetEvent mResetEvent = new ManualResetEvent(false);
        private volatile bool mIsAlive;
        private const int mTimeout = 6000000;

        public void Start()
        {
            if (mIsAlive == false)
            {
                mIsAlive = true;
                Thread thread = new Thread(new ThreadStart(RunThread));
                thread.Start();
            }
        }

        public void Stop()
        {
            mIsAlive = false;
            mResetEvent.Set();
        }

        public void RunThread()
        {
            while(mIsAlive)
            {
                //Reset the event -we may be restarting the thread.
                mResetEvent.Reset();

                DoWork();

                //The thread will block on this until either the timeout
                //expires or the reset event is signaled.
                if (mResetEvent.WaitOne(mTimeout))
                {
                    mIsAlive = false; // Exit the loop.
                }
            }
        }

        public void DoWork()
        {
            //...
        } }

Answer 5

So here's a sample that users timers to do the work as suggested by Brian. Use start/stop as needed. To cleanup the (Program) object once you are done with it make sure you call Dispose.

Just note that when you call Stop it will prevent the timer from firing again, however you still may have a worker thread in the middle of executing the timer_Elapsed handler, i.e. stopping the timer doesn't stop any currently executing worker thread.

using System;
using System.Timers;

namespace TimerApp
{
    class Program : IDisposable
    {
        private Timer timer;

        public Program()
        {
            this.timer = new Timer();
            this.timer.Elapsed += new ElapsedEventHandler(timer_Elapsed);
            this.timer.AutoReset = true;
            this.timer.Interval = TimeSpan.FromMinutes(10).TotalMilliseconds;
        }

        void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            // TODO...your periodic processing, executed in a worker thread.
        }

        static void Main(string[] args)
        {
            // TODO...your app logic.
        }

        public void Start()
        {
            this.timer.Start();
        }

        public void Stop()
        {
            this.timer.Stop();
        }

        public void Dispose()
        {
            this.timer.Dispose();
        }
    }
}