使用Parallel.ForEach启动两个并行任务

Question

In this code Parallel.ForEach is not waiting. Seconds elapsed is immediately returning 0. This code is in a PCL:

private void Button_Clicked(object sender, EventArgs e)
{
    Stopwatch watch = new Stopwatch();
    watch.Start();

    List<Task> taskList = new List<Task>();
    Task taskA = new Task(ExecuteTaskAAsync);
    Task taskB = new Task(ExecuteTaskBAsync);
    taskList.Add(taskA);
    taskList.Add(taskB);

    Parallel.ForEach(taskList, t => t.Start());

    watch.Stop();
    System.Diagnostics.Debug.WriteLine("Seconds Elapsed: " + watch.Elapsed.Seconds);
}

private async void ExecuteTaskAAsync()
{
    for (int i = 0; i < 10; i++)
    {
        System.Diagnostics.Debug.WriteLine("Task A: [{0}]", i + 1);
        await Task.Delay(1000);
    }

    System.Diagnostics.Debug.WriteLine("Finished Task A!");
}

private async void ExecuteTaskBAsync()
{
    for (int i = 0; i < 10; i++)
    {
        System.Diagnostics.Debug.WriteLine("Task B: [{0}]", i + 1);
        await Task.Delay(1000);
    }

    System.Diagnostics.Debug.WriteLine("Finished Task B!");
}

Responsible for this behavior seems to be t.Start() , which starts a new thread and Parallel.ForEach has finished. I also tried it by using Task as return type and this code:

Parallel.Invoke(async() => await ExecuteTaskAAsync(), async() => await ExecuteTaskBAsync());

Again seconds elapsed is immediately returning 0. How can I run both tasks parallel?

Answer 1

The parallel is working just fine - it's starting both tasks in parallel, just as your code is asking it to. It's just not waiting for those tasks to complete (and even if it was, those tasks aren't waiting for your async void methods to complete).

Since you're dealing with asynchronous tasks, what you really want is asynchronous concurrency , not parallel concurrency . They're both kinds of concurrency (doing more than one thing at the same time), but parallelism is about spawning multiple threads, whereas asynchrony is about freeing up the current thread.

Asynchronous concurrency works by using Task.WhenAll , as such:

private async void Button_Clicked(object sender, EventArgs e)
{
  Stopwatch watch = new Stopwatch();
  watch.Start();

  Task taskA = ExecuteTaskAAsync();
  Task taskB = ExecuteTaskBAsync();

  await Task.WhenAll(taskA, taskB);

  watch.Stop();
  System.Diagnostics.Debug.WriteLine("Seconds Elapsed: " + watch.Elapsed.Seconds);
}

private async Task ExecuteTaskAAsync()
{
  for (int i = 0; i < 10; i++)
  {
    System.Diagnostics.Debug.WriteLine("Task A: [{0}]", i + 1);
    await Task.Delay(1000);
  }

  System.Diagnostics.Debug.WriteLine("Finished Task A!");
}

private async Task ExecuteTaskBAsync()
{
  for (int i = 0; i < 10; i++)
  {
    System.Diagnostics.Debug.WriteLine("Task B: [{0}]", i + 1);
    await Task.Delay(1000);
  }

  System.Diagnostics.Debug.WriteLine("Finished Task B!");
}

Also note that I changed the existing async void methods to async Task ; this is because async void is unnatural and should be only used for event handlers. See my MSDN article on async best practices for more info.

As a final note, you should never use the Task constructor . I explain in detail on my blog, but it comes down to: there's always a better alternative.