Question

I have a method (let’s call it “CheckAll”) that is called from multiple areas of my program, and can therefore be called for a 2nd time before the 1st time has completed.

To get around this I have implemented a “lock” that (if I understand it correctly), halts the 2nd thread until the 1st thread has completed.

However what I really want is for this 2nd call to return to the calling method immediately (rather than halt the thread), and to schedule CheckAll to be run again once it has completed the 1st time.

I could setup a timer to do this but that seems cumbersome and difficult. Is there a better way?

Answer 1

Easy/cheap implementation.

private Thread checkThread = null;
private int requests = 0;

void CheckAll()
{
 lock(SyncRoot){
    if (checkThread != null; && checkThread.ThreadState == ThreadState.Running)
    {  
        requests++;
        return;
    }else
    {
        CheckAllImpl();
    }
 }

}

void CheckAppImpl()
{
 // start a new thread and run the following code in it.
  checkThread  = new Thread(newThreadStart( () => {
 while (true)
 {
 
 // 1. Do what ever checkall need to do.
 // 2.
     lock (SyncRoot)
     {
         requests--;
         if  (!(requests > 0))
            break;
     }
 }});
 checkThread.Start();
}

Just on a side note, this can have some race conditions. Better implementation would be to use ConcurrentQueue introduced in .NET 4 which handles all the threading craziness for you.

Update

Here’s a more ‘cool’ implementation using ConcurrentQueue (turns out we don’t need TPL):

public class CheckAllService
{
    // Make sure you don't create multiple 
    // instances of this class. Make it a singleton.

    // Holds all the pending requests
    private ConcurrentQueue<object> requests = new ConcurrentQueue<object>();

    private object syncLock = new object();

    private Thread checkAllThread;

    /// <summary>
    /// Requests to Check All. This request is async, 
    /// and will be serviced when all pending requests 
    /// are serviced (if any).
    /// </summary>
    public void RequestCheckAll()
    {
        requests.Enqueue("Process this Scotty...");

        lock (syncLock)
        {   // Lock is to make sure we don't create multiple threads.
            if (checkAllThread == null || 
                checkAllThread.ThreadState != ThreadState.Running)
            {
                checkAllThread = new Thread(new ThreadStart(ListenAndProcessRequests));
                checkAllThread.Start();
            }
        }
    }

    private void ListenAndProcessRequests()
    {
        while (requests.Count != 0)
        {
            object thisRequestData;
            requests.TryDequeue(out thisRequestData);
            try
            {
                CheckAllImpl();
            }
            catch (Exception ex)
            {
                // TODO: Log error ?
                // Can't afford to fail.
                // Failing the thread will cause all 
                // waiting requests to delay until another 
                // request come in.
            }
        }
    }

    protected void CheckAllImpl()
    {
        throw new NotImplementedException("Check all is not gonna write it-self...");
        // TODO: Check All
    }
}

Note

I use a real Thread instead of a TPL Task because a Task doesn’t hold on to a real thread as an optimization. When there’s no Thread, that means at the time your application closes, any waiting CheckAll requests are ignored. (I got bitten hard by this when I thought I’m so smart to call my logging methods in a task once, which ignored a couple of dozen log records when closing. CLR checks and waits for any waiting threads when gracefully exiting).