Multithreaded Service Engineering Questions

Question

I am trying to leverage .NET 4.5 new threading capabilities to engineer a system to update a list of objects in memory.

I worked with multithreading years ago in Java and I fear that my skills have become stagnant, especially in the .NET region.

Basically, I have written a Feed abstract class and I inherit from that for each of my threads. The thread classes themselves are simple and run fine.

Each of these classes run endlessly, they block until an event occurs and it updates the List.

So the first question is, how might I keep the parent thread alive while these threads run? I've prevented this race condition by writing this currently in a dev console app with a Console.read().

Second, I would like to set up a repository of List objects that I can access from the parent thread. How would I update those Lists from the child thread and expose them to another system? Trying to avoid SQL. Shared memory?

I hope I've made this clear. I was hoping for something like this: Writing multithreaded methods using async/await in .Net 4.5 except, we need the adaptability of external classes and of course, we need to somehow expose those Lists.

Answer 1

You can run the "parent" thread in a while with some flag to stop it:

while(flag){
    //run the thread
}

You can expose a public List as a property of some class to hold your data. Remember to lock access in multithreading code.

Answer 2

If the 'parent' thread is supposed to wait during the processing it could simply await the call(s) to the async method(s).

If it has to wait for specific events you could use a signaling object such as a Barrier.

If the thread has to 'do' things while waiting you could check the availability of the result or the progress: How to do progress reporting using Async/Await

Answer 3

If you're using tasks, you can use Tasks.WaitAll to wait for the tasks to complete. The default is that Tasks and async/await use your system's ThreadPool, so I'd avoid placing anything but relatively short running tasks here.

If you're using System.Threading.Thread (I prefer using these for long running threads), check out the accepted answer here: C# Waiting for multiple threads to finish

If you can fetch batches of data, you can expose services allowing access to the shared objects using self hosted Web API or something like NancyFX. WCF and remoting are also options if you prefer binary communication.

Shared memory, keep-alive TCP connections or UDP are options if you have many small transactions. Perhaps you could use ZeroMQ (it's not a traditional queue) with the C# binding they provide?

For concurrent access to the lists take a look at the classes in System.Collections.Concurrent before implementing your own locking.