Waiting for Parallel.For

Question

I know that there is no need to wait for a Parallel.For but since UI Windows messages (WinForms message pump) are being processed during the Parallel.For I would like to wait for Parallel.For to finish.

Is it a good idea to encapsulate a Parallel.For inside a Task, then wait for it? Is there any better approach?

Thanks.

CancellationTokenSource token = new CancellationTokenSource();

const int len = 100;

double[] array = new double[len];

Task t = Task.Factory.StartNew(delegate {
   Parallel.For(0, len, delegate(int i, ParallelLoopState loopState) {

   array[i] += 1;

   });

try
{
   t.Wait(token.Token);
}
catch (OperationCanceledException e)
{
   rc = false;
}

Answer 1

Instead of Parallel.For why not use just Task and call Task.WaitAll()?

var t1 = Task.Run(() => {});
var t2 = Task.Run(() => {});

Task.WaitAll(t1, t2);

Answer 2

If you want to wait for a Parallel.For() to finish, you simply don't start it in a separate task!

Parallel.For() doesn't return until it has completed (even if it uses multiple threads to do the work).

Note that Parallel.For() returns a ParallelLoopResult - it does not return a task or anything else which would allow you to wait for it to finish, so if it did return before it was complete (as you are asserting) there would be no way to know when it had finished.

Answer 3

What makes you be so confident that WM_PAINT and other Windows messages are pumped while Parallel.For or Task.Wait is blocking on the UI thread?

The following simple example proves you're wrong. The form is not getting repainted to red for the whole 15 seconds, while Parallel.For is working.

using System;
using System.Diagnostics;
using System.Drawing;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace WinFroms_21681229
{
    public partial class MainForm : Form
    {
        public MainForm()
        {
            InitializeComponent();

            this.Shown += MainForm_Shown;
        }

        void MainForm_Shown(object sender, EventArgs e)
        {
            MessageBox.Show("Before");

            this.BackColor = Color.FromName("red");
            this.Invalidate();

            // the form is not getting red for another 15 seconds
            var array = new double[] { 1, 2, 3 };
            Parallel.For(0, array.Length, (i) =>
            {
                System.Threading.Thread.Sleep(5000);
                Debug.Print("data: " + array[i]);
            });

            MessageBox.Show("After");
        }
    }
}

Here is how to run the tasks in parallel, while keeping the UI responsive:

async void MainForm_Shown(object sender, EventArgs e)
{
    MessageBox.Show("Before");

    this.BackColor = Color.FromName("red");
    this.Invalidate();

    // the form is not getting red for another 15 seconds
    var array = new double[] { 1, 2, 4 };

    var tasks = array.Select((n) => Task.Run(()=> 
    {
        Thread.Sleep(5000);
        Debug.Print("data: " + n);
    }));

    await Task.WhenAll(tasks);

    MessageBox.Show("After");
}

You could have done something like await Task.Factory.StartNew(() => Parallel.For(...)), but that would use at least one more thread than really needed.

To understand what's going on behind the scene here, you'd need to understand how WinForms message loop works inside Application.Run, how await yields the execution control back to the message loop and then gets continued via WindowsFormsSynchronizationContext, when the task has completed. The async-await tag wiki could help, it contains links to some great, must-read resources.

If you're interested to know how message pumping works during blocking operations, check this answer.