Is there any library for C# providing a thread pool that will execute no more than X tasks per unit of time?

Question

A problem is that a particular resource cannot handle more than 1 request per second and I want to pass that parameter to a thread pool that manages all concurrent calls to that resource.

Is there any library that offers such kind of custom thread pool or I should look forward to implement my own?

Thanks.

Answer 1

If you have only one ressource then you could thing of an input thread that feeds the ressource. The input thread also could have an input queue where all "task producer" feed in thir requests or jobs. The thing between the threads could be blocking queue:

blocking Queue

Answer 2

If you're using .NET 4, you can use a BlockingCollection<T> to accomplish this.

You can add your work items to the blocking collection from multiple threads in your application, then have a dedicated thread which calls GetConsumingEnumerable() to pull off items, and sleeps for the required time after processing each element to throttle to 1 request per second.

Answer 3

I'd spin off a thread, wrap it in a mutex, and force it to wait a second before releasing the lock. That way, in whatever process is generating these threads, each new thread will have to get in line before having access to the procedure.

The second thread will get spun off immediately, but will also immediately be queued because of the Mutex.

e.g.

{
Thread t = new Thread(()=>{DoSomething();}).Start();
Thread t2 = new Thread(()=>{DoSomething();}).Start();
}

private static Mutex _mutex = new Mutex();
private void DoSomething()
{
   _mutex.WaitOne();
   // Do Work
   Sleep(1000);
   _mutex.ReleaseMutex();
}

Optionally, if you really wanted to get specific, you could use the System.Diagnostics class to keep track of execution from start to finish of your procedure and make your Thread.Sleep only wait out the difference in execution time.

Kinda Hokey. =)

Answer 4

You could use Reactive Extensions from Microsoft Devlabs. There is a special Throttle operator that can limit the processing rate of an Observable.

Note that Reactive Extensions is not a final product, but you are free to use and distribute the library in its current form.

Answer 5

Might want to check out Quartz.Net

Answer 6

This is very similar to this question. I shamelessly recommend my answer.