CODEWITHSUNDEEP
c#multithreading
Jeff Reddy
Jeff Reddy

Reputation: 5670

Interrupt a sleeping Thread

Is there a way to Interupt a sleeping thread? If I have code similar to this.

while(true){
    if(DateTime.Now.Subtract(_lastExecuteTime).TotalHours > 1){
        DoWork();
        _lastExecuteTime = DateTime.Now();
        continue; 
    }
    Thread.Sleep(10000) //Sleep 10 seconds
    if(somethingIndicatingQuit){
        break;
    }

}

I'm wanting to execute DoWork() every hour. So, I'd like to sleep a little longer then 10 seconds. Say check every 10 minutes or so. However, if set my sleep to 10 minutes, and I want to kill this background task, I have to wait for the sleep to resume.

My actual code is using a Threading.ManualResetEvent to shut down the background work, but my issue is with the ThreadSleep code. I can post more code if necessary.

OK, I'm going to add a bit more complete code here as I think it will answer some of the questions.

private readonly ManualResetEvent _shutdownEvent = new ManualResetEvent(false);
private readonly ManualResetEvent _pauseEvent = new ManualResetEvent(true);
private Thread _backGroundWorkerThread;

//This starts our work
public void Start() {
    _backGroundWorkerThread = new Thread(ExecuteWorker) {IsBackground = true, Name = WorkerName + "_Thread"};
    _shutdownEvent.Reset();
    _backGroundWorkerThread.Start();
}
internal void Stop() {
    //Signal the shutdown event
    _shutdownEvent.Set();

    //Make sure to resume any paused threads
    _pauseEvent.Set();

    //Wait for the thread to exit
    _backGroundWorkerThread.Join();

}

private void ExecuteWorker() {
    while (true) {
        _pauseEvent.WaitOne(Timeout.Infinite);

        //This kills our process
        if (_shutdownEvent.WaitOne(0)) {
           break;
        }

        if (!_worker.IsReadyToExecute) {
            //sleep 5 seconds before checking again. If we go any longer we keep our service from shutting down when it needs to.
            Thread.Sleep(5000);
            continue;
        }
        DoWork();

    }
}

My problem is here, 

_backGroundWorkerThread.Join();

This waits for the Thread.Sleep within the ExecuteWorker() that is running in my background thread.

Upvotes: 19

Views: 36378

Answers (8)

Theodor Zoulias
Theodor Zoulias

Reputation: 43886

You are using a boolean flag (somethingIndicatingQuit) as an indicator that the while loop should exit. Hopefully this flag is declared as volatile, to prevent the compiler from potentially optimizing it away. My suggestion is to use instead the CancellationTokenSource+CancellationToken combination. This mechanism is designed specifically for communicating cancellation in multithreaded environments. You could use it like this:

private readonly CancellationTokenSource _cts = new();

//...

while(true)
{
    // Here do the main work...

    try
    {
        // Sleep for 10 seconds, or until the token is canceled.
        Thread.Sleep(10000, _cts.Token); // Cheating here, see below.
    }
    catch (OperationCanceledException)
    {
        // The token was canceled during the sleep.
        break;
    }
}

Then you can signal the cancellation from any thread by calling _cts.Cancel();.

Unfortunately the Thread.Sleep method does not include an overload that accepts a CancellationToken, so the above code won't compile. Fortunately implementing a cancelable Thread.Sleep is trivial. In the original version of my answer I had suggested using the Task.Delay like this:

public static void Sleep(int millisecondsTimeout, CancellationToken cancellationToken)
{
    Task.Delay(millisecondsTimeout, cancellationToken).GetAwaiter().GetResult();
}

The drawback is that the Task.Delay depends on the ThreadPool for its completion, so the signal might be delayed if the ThreadPool is saturated. For this reason I now suggest using a ManualResetEventSlim instead:

public static void Sleep(int millisecondsTimeout, CancellationToken cancellationToken)
{
    using ManualResetEventSlim mres = new();
    mres.Wait(millisecondsTimeout, cancellationToken);
}

This one does not depend on the ThreadPool, so the cancellation signal is transmitted instantaneously to the sleeping thread.

Upvotes: 5

TheCodeKing
TheCodeKing

Reputation: 19230

You can use Thead.Interrupt to wake a sleeping thread. It will cause a ThreadInterruptedException on the blocked thread, so it's not the most elegant or efficient approach.

You also need to be weary that interrupting a thread in this way is unsafe. It does not provide control over the point at which the thread is aborted, and therefore should not be used without careful consideration as to the consequences. As mentioned in other answers already, it's is far better to use signal based techniques to control when the thread terminates in a controlled manner.

Upvotes: 4

MobDev
MobDev

Reputation: 1632

You can wrap the Sleep(...) method to the SafeSleep(...) method can be interrupted with Thread.Interrupt();:

private void SafeSleep(int time)
{
    try
    {
        Thread.Sleep(time);
    }catch(ThreadInterruptedException)
    {
        Log.Debug("Thread sleep interrupted");
    }
}

Now the Thread will sleep during the sleep time or before the Thread.Interrupt() called. As the exception will be catched, the control will be returned to the Thread normal flow and you can terminate it right.

Upvotes: 0

schmendrick
schmendrick

Reputation: 471

why not use a BlockingCollection? I see it as a much more elegant approach than the accepted answer. i also do not think there is much overhead compared to the monitor.

here is how to do it:

initialize a BlockingCollection as a member:

BlockingCollection<int> _sleeper = new BlockingCollection<int>();

insted of 

Thread.Sleep(10000)

do this

int dummy;
_sleeper.TryTake(out dummy, 10000);

to wake it up you can use this code

_sleeper.Add(0);

Upvotes: 2

Jon Skeet
Jon Skeet

Reputation: 1503310

Instead of using Thread.Sleep, you can use Monitor.Wait with a timeout - and then you can use Monitor.Pulse from a different thread to wake it up.

Don't forget you'll need to lock on the monitor before calling either Wait or Pulse:

// In the background thread
lock (monitor)
{
    // If we've already been told to quit, we don't want to sleep!
    if (somethingIndicatingQuit)
    {
        break;
    }
    Monitor.Wait(monitor, TimeSpan.FromSeconds(10));
    if (somethingIndicatingQuit)
    {
        break;
    }
}

// To wake it up...
lock (monitor)
{
    somethingIndicatingQuit = true;
    Monitor.Pulse(monitor);
}

Upvotes: 48

Brian Gideon
Brian Gideon

Reputation: 48959

Instead of using Thread.Sleep use ManualResetEvent.WaitOne.

while (true) {
    if(DateTime.Now.Subtract(_lastExecuteTime).TotalHours > 1) {
        DoWork();
        _lastExecuteTime = DateTime.Now();
        continue; 
    }
    if (terminate.WaitOne(10000)) {
        break;
    }
}

Where terminate is a ManualResetEvent1 that you can Set to request termination of the loop.

Update:

I just noticed that you said you are already using ManualResetEvent to terminate the background work (I am assuming that is in DoWork). Is there any reason why you cannot use the same MRE? If that is not possible there certainly should not be an issue using a different one.

Update 2:

Yeah, so instead of Thread.Sleep(5000) in ExecuteWorker do _shutdownEvent.WaitOne(5000) instead. It would look like the following.

private void ExecuteWorker() {
    while (true) {
        _pauseEvent.WaitOne(Timeout.Infinite);

        //This kills our process
        if (_shutdownEvent.WaitOne(0)) {
           break;
        }

        if (!_worker.IsReadyToExecute) {
            //sleep 5 seconds before checking again. If we go any longer we keep our service from shutting down when it needs to.
            _shutdownEvent.WaitOne(5000);
            continue;
        }
        DoWork();
    }
}

1There is also a ManualResetEventSlim class in .NET 4.0.

Upvotes: 22

Martin James
Martin James

Reputation: 24907

If you want to DoWork() every hour, why not calculate the numer of ms required until the next hour is up and wait for that time? To cancel the sleep, you could either use a waitable synchro class, like the monitor as suggested by @Jon Skeet, or just set a flag in the thread that tells it to exit after the sleep instead of DoWork() and just forget about it - either the thread will kill itself when the time is up or your OS will kill it on app close, whichever comes first.

Rgds, Martin

Upvotes: 0

Tod
Tod

Reputation: 8252

Can't you just wrap your Thread.Sleep portion in a loop so that it loops 60 times then makes the other check? Of course all this does is trades off a simple if(somethingIndicatingQuit) versus the DateTIme if check, but assuming maybe you're real code does something more expensive, having a second loop could offer some minor CPU savings.

Upvotes: 0

Related Questions