Task Parallel Library如何执行负载平衡？

Question

We all know that in order to really perform asynchronous operations, our machine have to have multiple cores that each one of them will run its' own thread that will execute its' task.

Lets start with an example in which we have a quad core cpu and 4 tasks . In order to run our four tasks in real parallelism using C# we will have to create and run 4 tasks separately like so:

public static void Main()
{    
   // Define and run the tasks.
   Task[] tasks = {
      Task.Run( () => WorkA() ),
      Task.Run( () => WorkB() ),
      Task.Run( () => WorkC() ),
      Task.Run( () => WorkD() )
   }

   Task.WaitAll(tasks);
}

In this example TPL will supply each task with a thread from the ThreadPool and run each thread in a different processor if possible. (I hope I am right)

The scenario:

Lets say that we have quad core cpu and 6 tasks and we wrote the following code:

public static void Main()
{    
   // Define and run the tasks.
   Task[] tasks = {
      Task.Run( () => WorkA() ),
      Task.Run( () => WorkB() ),
      Task.Run( () => WorkC() ),
      Task.Run( () => WorkD() ),
      Task.Run( () => WorkE() ),
      Task.Run( () => WorkF() )
   }

   Task.WaitAll(tasks);
}

Will TPL know what is the best sufficient amount of threads and schedule the tasks among them? (considering the cores' states and the tasks' load differences)

for example:

• Total of 3 threads - 2 tasks per thread. (Lets say one core is busy)
• Total of 4 threads - 3 threads - 1 task per thread and 3 tasks for the last one.
• Total of 6 threads - 1 task per thread.

How does TPL perform load balancing? What TPL takes in consideration in order to provide the best load balancing..

Answer 1

Will TPL know what is the best sufficient amount of threads and schedule the tasks among them?

No. It's more complicated then you think:

Task.Run() adds a Task to the global queue. Suppose you already have 4 idle threads in your pool, then they will try to take Tasks from the global queue, an operation that involves synchronization and locks. Depends on the workload of each Task, it could be more efficient to let just one or two threads to handle all the tasks. And what if there is only one thread in the pool? Creating 3 more threads might be more expensive then the execution of the Tasks by the single thread. That information is not available during runtime, of course.