Multi-threading in C# .NET Windows Service

Question

I am writing a Windows Service (using C# .NET 3.5 VS2008) and my requirement is:

• When the Windows Service start - it performs record check operation (in Database) @ every 30 second interval (I have used a timer for this)

• If the appropriate record was found in the database - then it starts multiple threads and performs the required operation (that may be network operation or Database operation).

The number of multiple threads also depends on the amount of records found (like if 10 record found then starts 5 threads and for 20 records start 10 threads etc...) How to design/code for these multiple threads?

Example: 10 records found in the database, I want to start 5 threads for first 5 records which may perform network operation... out of 5 threads whichever thread completes his job - will start processing for next the record (i.e Record number 6, 7 ... 10)

Please suggest best possible solution for the above case.

Answer 1

I would recommend using Parallel.Net and PLINQ instead of explicit multi-threading. It's easier to manage, is more lightweight and will adapt itself to the numbers of core's you have

Learning resources

http://msdn.microsoft.com/en-us/concurrency/bb895950.aspx

Answer 2

on service start, launch a thread to run your timer process

on service end, kill all open threads

beware that any unhandled exception in your process will silently kill the timer thread

throttle the number of open threads allowed using a private list, to avoid flooding the service

you might find my SafeThread class useful for this

Answer 3

Initial thoughts: too many threads are bad for you. Unless the thread are IO bound (ie stuck waiting on IO operations for a large amount of their time) then you should have 2 threads per CPU as a rough rule-of-thumb.

As a reuslt, create a thread pool of a fixed number of threads, and simply reuse them. The design of the pool requires a semaphore - set the semaphore count to be the number of threads in the pool, allow through as many requests as the semaphore counts up to, then the semaphore will block until the threads complete (when this happens, you decrement the semaphore count) which will allow the next request through. This works because a semaphore is simply a "multi-lock" mutex. It lets through as many calls as you've specified and then it blocks. A mutex is in fact a semaphore with a count of 1.