CODEWITHSUNDEEP
c#multithreadingtask-parallel-library
stevcode
stevcode

Reputation: 171

In C#, how do I call a method at random intervals on a separate thread but have it always process sequentially?

This seems like it has a very simple solution, but I've been looking on and off for months without finding a definitive answer.

I have an object being created by the UI Thread. I'm actually creating several of the same type of object. Sometimes I'll create 1 or 2 every minute, sometimes I'll create 30 in a second. Each time an object it created, I need to perform some calculations on the object. The combination of potentially 30 objects created at in a short time, and the expensive calculations I'm performing on said objects can really lag the UI.

I've tried performing the calculations via Tasks and backgroundWorkers and all sorts of threading but they all perform the calculations out of order, and it's imperative that the objects are calculated in the order they are created and that one doesn't start it's calculations until the object ahead of it finishes it's own calculations.

I can find all sorts of information about how to perform these tasks in parallel, but can anyone explain to me how I can force them to happen sequentially, just not on the UI Thread? Any help would be greatly appreciated. I've been trying to figure this out for months :(

Upvotes: 2

Views: 370

Answers (3)

noseratio
noseratio

Reputation: 61706

IMO, the easiest way to run tasks in sequential order here is to use Task.ContinueWith. Note TaskContinuationOptions.LazyCancellation, it's used to make sure that cancellation doesn't break the order of the sequence:

Task _currentTask = Task.FromResult(Type.Missing);
readonly object _lock = new Object();

void QueueTask(Action action)
{
    lock (_lock)
    {
        _currentTask = _currentTask.ContinueWith(
            lastTask => 
            {
                // re-throw the error of the last completed task (if any)
                lastTask.GetAwaiter().GetResult();
                // run the new task
                action();
            },
            CancellationToken.None, 
            TaskContinuationOptions.LazyCancellation, 
            TaskScheduler.Default);
    }
}

private void button1_Click(object sender, EventArgs e)
{
    for(var i = 0; i < 10; i++)
    {
        var sleep = 1000 - i*100;
        QueueTask(() => 
        { 
            Thread.Sleep(sleep); 
            Debug.WriteLine("Slept for {0} ms", sleep); 
        });
    }
}

Upvotes: 2

Yuval Itzchakov
Yuval Itzchakov

Reputation: 149548

I think a proper solution would be to use a Queue, as it is FIFO in a task that is running in the background.

Your code could look something like this:

Edit

Edited to use Queue.Synchronize as @rwong mentioned (thanks!)

var queue = new Queue<MyCustomObject>();
//add object to the queue..
var mySyncedQueue = Queue.Synchronize(queue)

Task.Factory.StartNew(() =>
{
    while (true)
    {
        var myObj = mySyncedQueue.Dequeue();
        if (myObj != null)
        { do work...}
    } 
}, TaskCreationOptions.LongRunning);

This is just to get you started, im sure your could could be more efficient when you know exactly what is needed :)

Edit 2

As you are accessing the queue from multiple threads, it is better to use a ConcurrentQueue. the method wont look much different:

var concurrentQueue = new ConcurrentQueue<MyCustomObject>();
//add object to the queue..

Task.Factory.StartNew(() =>
{
    while (true)
    {
        MyCustomObject myObj;
        if (concurrentQueue.TryDequeue(myObj))
        { do work...}
    } 
}, TaskCreationOptions.LongRunning);

Upvotes: 2

Mattias &#197;slund
Mattias &#197;slund

Reputation: 3907

Create exactly one background task. Then let it process all items in a thread-safe fifo buffer. Add objects to the fifo from your gui thread.

Upvotes: 1

Related Questions