Exiting a thread that does not have a loop

Question

I need a way to stop a worker thread that does not contain a loop. The application starts the thread, the thread then creates a FileSystemWatcher object and a Timer object. Each of these has callback functions. What I have done so far is add a volatile bool member to the thread class, and use the timer to check this value. I'm hung up on how to exit the thread once this value is set.

    protected override void OnStart(string[] args)
    {
      try
      {
        Watcher NewWatcher = new Watcher(...);
        Thread WatcherThread = new Thread(NewWatcher.Watcher.Start);
        WatcherThread.Start();
      }
      catch (Exception Ex)
      {
          ...
      }
    }

public class Watcher
{
    private volatile bool _StopThread;

    public Watcher(string filePath)
    {
        this._FilePath = filePath;
        this._LastException = null;

        _StopThread = false;
        TimerCallback timerFunc = new TimerCallback(OnThreadTimer);
        _ThreadTimer = new Timer(timerFunc, null, 5000, 1000);
    }   

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

    public void Stop()
    {
        _StopThread = true;
    }

    private void CreateFileWatch()
    {
        try
        {
            this._FileWatcher = new FileSystemWatcher();
            this._FileWatcher.Path = Path.GetDirectoryName(FilePath);
            this._FileWatcher.Filter = Path.GetFileName(FilePath);
            this._FileWatcher.IncludeSubdirectories = false;
            this._FileWatcher.NotifyFilter = NotifyFilters.LastWrite;
            this._FileWatcher.Changed += new FileSystemEventHandler(OnFileChanged);

            ...

            this._FileWatcher.EnableRaisingEvents = true;
        }
        catch (Exception ex)
        {
            ...
        }
    }

    private void OnThreadTimer(object source)
    {
        if (_StopThread)
        {
            _ThreadTimer.Dispose();
            _FileWatcher.Dispose();
            // Exit Thread Here (?)
        }
    }

    ...
}

So I can dispose the the Timer / FileWatcher when the thread is told to stop - but how do I actual exit/stop the thread?

Answer 1

Rather than a Boolean flag, I would suggest using a ManualResetEvent. The thread starts the FileSystemWatcher, then waits on an event. When Stop is called, it sets the event:

private ManualResetEvent ThreadExitEvent = new ManualResetEvent(false);

public void Start()
{
    // set up the watcher
    this.CreateFileWatch();

    // then wait for the exit event ...
    ThreadExitEvent.WaitOne();

    // Now tear down the watcher and exit.
    // ...
}

public void Stop()
{
    ThreadExitEvent.Set();
}

This prevents you from having to use a timer, and you'll still get all your notifications.

Answer 2

The thread will exit when the Start method exits. By the time you get to the Timer, it's already gone.

Answer 3

Do not use Thread.Start !

Use TPL, Rx, BackgroundWorker or something higher level.

Answer 4

There are generally speaking 2 ways to do this

• Use Thread.Abort() to abort the thread. This is largely considered a very dangerous operation as it will effectively throw an exception and use this to exit the thread. This can very easily lead to leaked resources or forever locked mutexes if the code is not adequetely prepared. I would avoid this approach
• Check the _StopThread value at prescribed places and either return out of the method or throw an exception to get back to the thread start and gracefully exit the thread from there. This is the approach favored by the TPL code base (cancellation tokens)

Answer 5

In your case, the thread does not do anything as it exits right away. You could create the Watcher object in your main thread as well.

The Watcher continues to exist even after the creating thread terminated. To get rid of it, use Dispose.

Or, more specifically, why do you even want to use a thread? To handle the events on a different thread from the main thread? In that case, create a new thread in the Watcher event handler.

This again has to be done carefully to avoid excessive thread creation. A typical solution is to use a thread pool / background workers.

Answer 6

http://msdn.microsoft.com/en-us/library/dd997423.aspx

You cannot cancel a FromAsync task, because the underlying .NET Framework APIs currently do not support in-progress cancellation of file or network I/O. You can add cancellation functionality to a method that encapsulates a FromAsync call, but you can only respond to the cancellation before FromAsync is called or after it completed (for example, in a continuation task).