Question

Basically I have a static custom queue of objects I want to process. From multiple threads, I need to kick off a singular Task that will process the queued objects, stopping the task when all items are dequeued.

Some psuedo code:

static CustomQueue _customqueue;
static Task _processQueuedItems;

public static void EnqueueSomething(object something) {
    _customqueue.Enqueue(something);
    StartProcessingQueue();
}

static void StartProcessingQueue() {
   if(_processQueuedItems != null) {
      _processQueuedItems = new Task(() => {
        while(_customqueue.Any()) {
            var stuffToDequeue = _customqueue.Dequeue();
            /* do stuff */
        }
      });
     _processQueuedItems.Start();
   }
   if(_processQueuedItems.Status != TaskStatus.Running) {
      _processQueuedItems.Start();
   }
}

If it makes a difference my custom queue is a queue that essentially holds items until they reach a certain age, then allows them to dequeue. Everytime an item is touched its timer starts again. I know this piece works fine.

The part I’m struggling with is the parallelism. (Clearly, I don’t know what I’m doing here). What I want is to have one thread process the queue until it’s complete, then go away. If another call comes in it doesn’t start a new thread unless it has to.

I hope that explains my issue okay.

Answer 1

You might want to consider using BlockingCollection<T> here. You could make your custom queue implement IProducerConsumerCollection, in which case BC could use it directly.

You’d then just need to start a long running Task to call blockingCollection.GetConsumingEnumerable() and process the items in a foreach. The task will automatically block when the collection is empty, and restart when a new item is Enqueued.