CODEWITHSUNDEEP
c#multithreading
ebb
ebb

Reputation: 9377

Multiple Tasks slows down

The code:

static void DoIt(string name)
{
    Console.WriteLine("Hello {0} | {1}", name, Thread.CurrentThread.ManagedThreadID);
    Thread.Sleep(5000);
    Console.WriteLine("Bye {0} | {1}", name, Thread.CurrentThread.ManagedThreadID);
}

static void Main()
{
    Task.Factory.StartNew(() => DoIt("One"));
    Task.Factory.StartNew(() => DoIt("Two"));
    Task.Factory.StartNew(() => DoIt("Three"));
    Task.Factory.StartNew(() => DoIt("Four"));
    Task.Factory.StartNew(() => DoIt("Five"));
    Task.Factory.StartNew(() => DoIt("Six"));
    Task.Factory.StartNew(() => DoIt("Seven"));
    Task.Factory.StartNew(() => DoIt("Eight"));
    Task.Factory.StartNew(() => DoIt("Nine"));
    Task.Factory.StartNew(() => DoIt("Ten"));

    Console.ReadKey();
}

How come that it can fine start the first 3 Tasks immediately, but then it takes 5-10sec for Task 4 to start, and after Task 4 have started, then it takes 5-10sec before Task 5 starts and so on. Is it the GC thats doing something? Could someone please clarify whats happening?

Upvotes: 18

Views: 6296

Answers (3)

Adam Maras
Adam Maras

Reputation: 26853

The tasks aren't slowing down, they're being queued by the Task Parallel Library. The CLR knows how many logical cores are available on your computer; TPL the thread pool uses this information to determine how many worker threads to make available. In your case, you probably have four logical cores; taking one away for the main thread (on which Main() is running) three cores (and three thread pool workers) remain to execute tasks.

Upvotes: 6

Reed Copsey
Reed Copsey

Reputation: 564403

How come that it can fine start the first 3 Tasks immediately, but then it takes 5-10sec for Task 4 to start, and after Task 4 have started, then it takes 5-10sec before Task 5 starts and so on. Is it the GC thats doing something? Could someone please clarify whats happening?

By default, the first time you run this, the ThreadPool is allocated using the minimum number of worker threads. After the first 4 tasks are scheduled, the threadpool will "ramp up" to handle more over time, which is why you see the delay.

On my system (which has 8 cores), the first 8 are instantanteous, then the next two start up one second later.

In your case, if you run your test two times, the second time, the threads will all start up immediately. This is because, after the first run, the ThreadPool should have enough workers to schedule this right away.

Try the following to see this behavior in action. If you leave the SetMinThreads call in place, these will all schedule immediately. If you comment it out, you'll see that, the first time, it takes a while, but the second time through (provided you wait for the threads to complete), the threads will run immediately.

static void DoIt(string name)
{
    Console.WriteLine("Hello {0} | {1} - {2}", name, Thread.CurrentThread.ManagedThreadId, DateTime.Now);
    Thread.Sleep(5000);
    Console.WriteLine("Bye {0} | {1} - {2}", name, Thread.CurrentThread.ManagedThreadId, DateTime.Now);
}

static void Main()
{
    int workerThreads, complete;
    ThreadPool.GetMinThreads(out workerThreads, out complete);

    Console.WriteLine(workerThreads);

    // Comment out this line to see the difference...
    // WIth this commented out, the second iteration will be immediate
    ThreadPool.SetMinThreads(100, complete);

    Action run = () =>
        {
            for (int i = 0; i < 20; ++i)
            {
                int tmp = i;
                Task.Factory.StartNew(() => DoIt(tmp.ToString()));
            }
        };

    run();
    Console.WriteLine("Press a key to run again...");
    Console.ReadKey();

    run();

    Console.WriteLine("Press a key to exit...");
    Console.ReadKey();
}

Note that this behavior actually has little to do with the TPL as a whole - it's more the default TaskScheduler used which just passes off the tasks to the ThreadPool. If you were to set these threads up with the LongRunning hint in your StartNew() call, for example, they'd all start immediately (since the default scheduler will setup a new, dedicated thread and execute it immediately).

Upvotes: 18

Bryan Crosby
Bryan Crosby

Reputation: 6554

The TPL contains very sophisticated algorithms which adapt to the workload. What you are experiencing sounds about right for a 4-core machine -- the TPL has decided to do something that it thinks is beneficial in a situation where so many threads are created.

Upvotes: 0

Related Questions