Cancel tasks in Parallel.Invoke

Question

As I understand it, all three static methods in Parallel (For, ForEach and Invoke) create tasks in the background.

You can stop creating these tasks with cancel a token inside ParallelOptions.

I made two simple examples.

In the first uses the For method in the second Invoke.

In the case of the For method, the behavior is expected, after canceling the token, the creation of new tasks is stopped. In the case of the Invoke method, this does not happen. No matter how many methods I put in the Invoke method, they are always executed after the token is canceled. And I don't understand why this is happening.

On learn.microsoft.com in Parallel.Invoke method It's been said:

The cancellation token passed in with the ParallelOptions structure enables the caller to cancel the entire operation.

Question: Why in the case of the Invoke method, all tasks are executed and canceling the token does nothing? Or maybe I'm doing something wrong, then tell me what.

using System;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class MyClass
    {
        public int a = 0;
        public void Add()
        {
            lock (this)
            {
                Thread.Sleep(100);
                Console.WriteLine($"Do Add {DateTime.Now}, a={a}");
                a++;
            }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            void MyMethodForCancel(CancellationTokenSource cancellationTokenSource)
            {
                Random random = new Random();

                while (true)
                {
                    if (random.Next(1, 100) == 50)
                    {
                        cancellationTokenSource.Cancel();
                        Console.WriteLine($"Cancel token {DateTime.Now}");
                        return;
                    }
                }
            }

            CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
            ParallelOptions parallelOptions = new ParallelOptions();
            parallelOptions.CancellationToken = cancellationTokenSource.Token;

            MyClass myClass2 = new MyClass();
            Action[] actions = new Action[50];

            for (int i = 0; i < actions.Length; i++)
            {
                actions[i] = myClass2.Add;
            }

            Task MyTask1 = Task.Run(() => Parallel.Invoke(parallelOptions, actions));
            Task MyTask2 = Task.Run(() => { Thread.Sleep(1); MyMethodForCancel(cancellationTokenSource); });

            try
            {
                Task.WaitAll(MyTask1, MyTask2);
            }
            catch
            {

            }

            Console.WriteLine($"a = {myClass2.a}"); //a = 50. Always.               
        }
    }
}

Answer 1

Here is my attempt to confirm your claim, that the Parallel.Invoke method ignores the CancellationToken passed to its options. I am creating a CancellationTokenSource that is canceled with a timer after 700 msec, and 20 Actions that each requires 500 msec to complete. Let's pass these 20 actions to Parallel.Invoke, and see what happens:

static class Program
{
    static void Main()
    {
        var cts = new CancellationTokenSource(700);
        cts.Token.Register(() => Print($"The Token was canceled."));
        var options = new ParallelOptions()
        {
            MaxDegreeOfParallelism = 2,
            CancellationToken = cts.Token
        };
        Print("Before starting the Parallel.Invoke.");
        try
        {
            Parallel.Invoke(options, Enumerable.Range(1, 20).Select(i => new Action(() =>
            {
                Print($"Running action #{i}");
                Thread.Sleep(500);
            })).ToArray());
        }
        catch (OperationCanceledException)
        {
            Print("The Parallel.Invoke was canceled.");
        }
    }

    static void Print(object value)
    {
        Console.WriteLine($@"{DateTime.Now:HH:mm:ss.fff} [{Thread.CurrentThread
            .ManagedThreadId}] > {value}");
    }
}

Output:

12:12:46.422 [1] > Before starting the Parallel.Invoke.
12:12:46.450 [1] > Running action #1
12:12:46.451 [5] > Running action #2
12:12:46.951 [1] > Running action #3
12:12:46.951 [5] > Running action #4
12:12:47.122 [7] > The Token was canceled.
12:12:47.458 [1] > The Parallel.Invoke was canceled.

Try it on Fiddle.

It seems that the CancellationToken is respected. Only 4 of the 20 actions are executed, and no more actions are invoked after the cancellation of the token.

Notice however that I have configured the Parallel.Invoke with a small MaxDegreeOfParallelism. This is important. If instead I configure this option with a large value, like 100, or leave it to its default value which is -1 (unbounded), than all 20 actions will be invoked. What happens in this case is that the ThreadPool is saturated, meaning that all the available ThreadPool threads are borrowed aggressively by the Parallel.Invoke method, and there is no available thread to do other things, like invoking the scheduled cancellation of the CancellationTokenSource! So the cancellation is postponed until the completion of the Parallel.Invoke, which is obviously too late.

The moral lesson is: always configure the MaxDegreeOfParallelism option whenever you use the Parallel class. Don't believe the documentation that says: "Generally, you do not need to modify this setting". This is a horrible advice. You should only follow this advice if your intention is to starve your ThreadPool to death.