How to limit the Maximum number of parallel tasks in c#

Question

I have a collection of 1000 input message to process. I'm looping the input collection and starting the new task for each message to get processed.

//Assume this messages collection contains 1000 items var messages = new List<string>();  foreach (var msg in messages) {    Task.Factory.StartNew(() =>    {     Process(msg);    });  } 

Can we guess how many maximum messages simultaneously get processed at the time (assuming normal Quad core processor), or can we limit the maximum number of messages to be processed at the time?

How to ensure this message get processed in the same sequence/order of the Collection?

Answer 1

SemaphoreSlim is a very good solution in this case and I higly recommend OP to try this, but @Manoj's answer has flaw as mentioned in comments.semaphore should be waited before spawning the task like this.

Updated Answer: As @Vasyl pointed out Semaphore may be disposed before completion of tasks and will raise exception when Release() method is called so before exiting the using block must wait for the completion of all created Tasks.

int maxConcurrency=10; var messages = new List<string>(); using(SemaphoreSlim concurrencySemaphore = new SemaphoreSlim(maxConcurrency)) {     List<Task> tasks = new List<Task>();     foreach(var msg in messages)     {         concurrencySemaphore.Wait();          var t = Task.Factory.StartNew(() =>         {             try             {                  Process(msg);             }             finally             {                 concurrencySemaphore.Release();             }         });          tasks.Add(t);     }      Task.WaitAll(tasks.ToArray()); } 

Answer to Comments for those who want to see how semaphore can be disposed without Task.WaitAll Run below code in console app and this exception will be raised.

System.ObjectDisposedException: 'The semaphore has been disposed.'

static void Main(string[] args) {     int maxConcurrency = 5;     List<string> messages =  Enumerable.Range(1, 15).Select(e => e.ToString()).ToList();      using (SemaphoreSlim concurrencySemaphore = new SemaphoreSlim(maxConcurrency))     {         List<Task> tasks = new List<Task>();         foreach (var msg in messages)         {             concurrencySemaphore.Wait();              var t = Task.Factory.StartNew(() =>             {                 try                 {                     Process(msg);                 }                 finally                 {                     concurrencySemaphore.Release();                 }             });              tasks.Add(t);         }         // Task.WaitAll(tasks.ToArray());     }     Console.WriteLine("Exited using block");     Console.ReadKey(); }  private static void Process(string msg) {                 Thread.Sleep(2000);     Console.WriteLine(msg); } 

Answer 2

You could use Parallel.Foreach and rely on MaxDegreeOfParallelism instead.

Parallel.ForEach(messages, new ParallelOptions {MaxDegreeOfParallelism = 10}, msg => {      // logic      Process(msg); });