CancellationToken 行为

Question

我想了解CancellationToken 的工作原理，以及它如何取消任务。

为此，我创建了这个示例，它对 Task.Run() 和内部方法使用相同的标记 - HelpDoingSomething()

所以，我让任务运行500ms，然后我取消token，结果是：

第一个打印消息：“HelpDoingSomething cancelled”，然后 “DoSomething cancelled”

class Program
{
    static void Main(string[] args)
    {
        var cts = new CancellationTokenSource();

        var myClass = new MyClass(cts.Token);
        myClass.DoSomething();

        Thread.Sleep(500);
        cts.Cancel();

        System.Console.ReadKey();
    }
}

internal class MyClass
{
    private CancellationToken token;

    public MyClass(CancellationToken token)
    {
        this.token = token;
    }

    public void DoSomething()
    {
        Task.Run(() =>
        {
            HelpDoingSomething();
            System.Console.WriteLine("DoSomething cancelled");
        }, token);
    }

    private void HelpDoingSomething()
    {
        while (!token.IsCancellationRequested)
        {
            //Keep doing something
            System.Console.Write(".");
        }

        System.Console.WriteLine("HelpDoingSomething cancelled");
    }
}

我确切地知道我的方法HelpDoingSomething() 检查是否在循环的每次迭代中都请求了cancellationToken。

我的问题是Task.Run() 方法检查是否请求取消令牌的频率和频率？

Task.Run() 是否可能会在 HelpDoingSomething() 之前检查，而我只会看到一条消息打印（“DoSomething cancelled”）？这意味着该方法可能无法正确处理逻辑。

Answer 1

在两个地方检查传递给Task.Run() 的取消令牌：

(1) 在任务真正开始之前。

如果在任务开始之前发出取消标记，任务将很快进入“WaitingToRun”状态，然后是“Cancelled”状态。

在这种情况下将不会启动传递给任务的操作。

如果在调用Task.Run() 后很快检查任务的状态，则可能会观察到“WaitingToRun”状态，但这将是一个竞争条件，并且可能不会观察到该状态。但是，“已取消”状态将始终被设置。

(2) 当传递给任务的动作抛出OperationCancelledException。

在情况 (1) 中，任务将短暂转换到可能可以观察到的“WaitingToRun”状态，但与情况 (1) 不同的是，这很快就会进入“正在运行”状态（假设取消令牌已取消任务开始后）。

如果与OperationCancelledException 关联的令牌与传递给Task.Run() 的令牌相同，则任务将转换为“已取消”状态，否则将转换为“故障”状态。

详情请看这里：https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/task-cancellation

这是一个示例控制台应用程序，它演示了其中一些案例：

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

static class Program
{
    public static void Main()
    {
        Console.WriteLine("Test with already-cancelled token, but not passed to Task.Run()");
        CancellationTokenSource alreadyCancelled = new CancellationTokenSource();
        alreadyCancelled.Cancel();

        Task test1 = Task.Run(() => Test(alreadyCancelled.Token));

        Console.WriteLine("test1 status: " + test1.Status); // Probably "WaitingToRun", but this has a race condition.
        Thread.Sleep(200);
        Console.WriteLine("test1 status: " + test1.Status); // Certainly "Faulted".

        Console.WriteLine("\nTest with already-cancelled token passed to Task.Run()");
        Task test2 = Task.Run(() => Test(alreadyCancelled.Token), alreadyCancelled.Token);

        Console.WriteLine("test2 status: " + test2.Status); // Probably "WaitingToRun", but this has a race condition.
        Thread.Sleep(200);
        Console.WriteLine("test2 status: " + test2.Status); // Certainly "Cancelled".

        Console.WriteLine("\nTest with token cancelled after starting task, but not passed to Task.Run()");
        CancellationTokenSource cts3 = new CancellationTokenSource();
        Task test3 = Task.Run(() => Test(cts3.Token));

        Console.WriteLine("test3 status: " + test3.Status); // Probably "WaitingToRun", but this has a race condition.
        Thread.Sleep(200);
        Console.WriteLine("test3 status: " + test3.Status); // Certainly "Running".

        cts3.Cancel();
        Thread.Sleep(200);
        Console.WriteLine("test3 status: " + test3.Status); // Certainly "Faulted".

        Console.WriteLine("\nTest with token cancelled after starting task passed to Task.Run()");
        CancellationTokenSource cts4 = new CancellationTokenSource();
        Task test4 = Task.Run(() => Test(cts4.Token), cts4.Token);

        Console.WriteLine("test4 status: " + test4.Status); // Probably "WaitingToRun", but this has a race condition.
        Thread.Sleep(200);
        Console.WriteLine("test4 status: " + test4.Status); // Certainly "Running".

        cts4.Cancel();
        Thread.Sleep(200);
        Console.WriteLine("test4 status: " + test4.Status); // Certainly "Cancelled".

        Console.ReadLine();
    }

    public static void Test(CancellationToken cancellation)
    {
        Console.WriteLine("Entering Test()");
        cancellation.WaitHandle.WaitOne();
        Console.WriteLine("Cancellation detected");
        cancellation.ThrowIfCancellationRequested();
    }
}

（在 cmets 中说“当然”有点谎言，但在正常情况下，200ms 应该远远超过观察到该状态的转换。如果不这样做，请增加超时时间。这不是在生产代码中要做的事情！）

由此产生的输出是：

Test with already-cancelled token, but not passed to Task.Run()
test1 status: WaitingToRun
Entering Test()
Cancellation detected
test1 status: Faulted

Test with already-cancelled token passed to Task.Run()
test2 status: WaitingToRun
test2 status: Canceled

Test with token cancelled after starting task, but not passed to Task.Run()
test3 status: WaitingToRun
Entering Test()
test3 status: Running
Cancellation detected
test3 status: Faulted

Test with token cancelled after starting task passed to Task.Run()
test4 status: WaitingToRun
Entering Test()
test4 status: Running
Cancellation detected
test4 status: Canceled

注意对于第二种情况“使用已取消的令牌传递给 Task.Run() 的测试”，Entering Test() 未写入控制台，因为未调用该操作。这是唯一一个根本不调用操作的测试用例。