同步运行任务的目的是什么，何时执行？

Question

what is the purpose of running task synchronously

public static void RunMeSync()
{
  for(int i = 0; i < 9999; i++)
  {
    ListBox1.Items.Add(i.ToString());
  }
}
public static void Main()
{
  Task T1 = new Task(()=>RunMeSync);
  T1.RunSynchronously();
  Task T2 = Task.Run(()=>RunMeSync);
}

is it pointless to do so ? what is the need to run task synchronously ?
Consider the following code snippet

public static void Main()
{
  Task T1 = new Task(()=>RunMeSync);
  T1.RunSynchronously();
  RunMeSync();
}

is it the same thing running T1 Synchronously, invoking RunMeSync directly?

Answer 1

Is it the same thing running T1 Synchronously, invoking RunMeSync directly?

Yes, the effect is going to be the same. You would not gain anything by running synchronously a task constructed from a method that you could call directly.

However, not all tasks are like that: some are constructed from methods to which you have no access - for example, tasks passed into your class as parameters. In other cases a task would have no named method associated with it, because it is constructed from a lambda or with an anonymous delegate. In all these cases, RunSynchronously() provides a way to calling the logic that implements the task, without knowing or worrying about the way in which that logic has been defined.

Answer 2

A Task itself is just a unit of work - and as-such, is agnostic to how it is run.

It's entirely up to you to determine how it is run, based upon the needs, constraints and context of your program (albeit defaulting to potentially running in parallel)

Answer 3

The name RunSynchronously is a quite a bit of misnomer, better name would be TryToRunSynchronously . Method will wait for the task to complete anyway irrespective of which thread it ran, maybe that's why they picked up this name.

Yes, as the name suggests Task will not be always run synchronously in current thread. If the underlying scheduler refuses to inline, Task will still be queued for execution and wait for it to complete. TaskScheduler.TryExecuteTaskInline decides whether the Task is a candidate for inlining or not, another one parameter deciding the task inlining is the amount of stack available. So it is not same as calling the method synchronously.

It might be helpful when you're dealing with some very deep recursive algorithms. Very deep recursion can cause StackOverflowException , you can check whether you have enough stack to proceed the recursion, if not just execute the Task in another thread (In fact that's how it is implemented).

Consider we are parallelizing some work. We split the work across threads and each of them does some deep recursion, If you're doing this with traditional recursive function, you'll end up with StackOverflowException . But if you wrap the recursive method logic inside Task.RunSynchronously then it will automatically stop recursing and queue the task to the underlying Scheduler and wait for it to complete if there is not enough stack available.