Task based concurrency much slower than when directly using System.Threading.Thread

Question

I've been using System.Threading.Task and System.Net.Http.HttpClient to load test a web server and have observed some strange behavior. Here is the code:

var taskArray = new List<Task>();              
for (int i = 0; i < 105; i++)
    taskArray.Add(Task.Factory.StartNew(() => Get("/content/test.jpg")));

Task.WaitAll(taskArray.ToArray());

Even though each request (when monitored via fiddler), only took a around 15ms to execute, I was getting timeout exceptions (well, TaskCanceledExcpetions - which is the same thing) thrown by the HttpClient being used to make the request when the request time exceeded the default timeout of 100 seconds.

The first thing I tried was increasing the timeout on HttpClient, which worked, but I was still struggling to understand why requests with a very short response time were timing out. So I set a timer before I made the call to HttpClient.PostAsync and checked how long it took to complete, as suspected, the time was over 100 seconds, despite the server sending a response much more promptly.

I then read that HttpClient.Timeout is the timeout for the entire async operation, which made me think that perhaps the task scheduler was causing me problems by only executing the async callback that received the response a good while after the response was ready to be received.

With this in mind, I decided to write the code using the good old System.Threading.Thread :

var handle = new EventWaitHandle(false, EventResetMode.ManualReset);
for (int i = 0; i < 105; i++)
{
    var t = new Thread(() =>
    {
        Get("/content/test.jpg");
        if (Interlocked.Decrement(ref numberOfTasks) == 0)
            handle.Set();
    });
    t.Start();
}

handle.WaitOne();

This works as expected! I can even crank the number of threads up to 2000 and it completes all of them more quickly than the Task based version took to send 105!

What gives?

Answer 1

As mentioned by Matthew, this is due to the fact that the Task factory uses thread pooling by default. Raising the limit slightly, or creating your own threadpool might have some value for you if you want to use tasks and want to raise the threadpool limit.

That said, you're already working with a class that has all asynchronous methods: why are you trying to wrap those in threads? Just capture the tasks and wait them.

Something like this:

var tasks = new List<Task>();              
for (int i = 0; i < 105; i++)
    tasks.Add(client.GetAsync(uri));

Task.WaitAll(tasks.ToArray());