1

我有两个直接来自 microsoft 的示例，这些示例似乎与取消令牌无关，因为我可以删除提供给任务的令牌，结果是相同的。所以我的问题是：取消令牌的用途是什么，为什么这些例子不好？我错过了什么..？:)

using System;
using System.Threading;
using System.Threading.Tasks;
namespace Chapter1.Threads
{
    public class Program
    {
        static void Main()
        {
            CancellationTokenSource cancellationTokenSource =
                new CancellationTokenSource();
            CancellationToken token = cancellationTokenSource.Token;
            Task task = Task.Run(() =>
            {
                while (!token.IsCancellationRequested)
                {
                    Console.Write(“*”);
                    Thread.Sleep(1000);
                }
                token.ThrowIfCancellationRequested();
            }, token);
            try
            {
                Console.WriteLine(“Press enter to stop the task”);
                Console.ReadLine();
                cancellationTokenSource.Cancel();
                task.Wait();
            }  
            catch (AggregateException e)
            {
                Console.WriteLine(e.InnerExceptions[0].Message);
            }
            Console.WriteLine(“Press enter to end the application”);
            Console.ReadLine();
        }
    }
}

代码示例2： https ://msdn.microsoft.com/en-us/library/system.threading.cancellationtoken(v=vs.110).aspx

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      // Define the cancellation token.
      CancellationTokenSource source = new CancellationTokenSource();
      CancellationToken token = source.Token;

      Random rnd = new Random();
      Object lockObj = new Object();

      List<Task<int[]>> tasks = new List<Task<int[]>>();
      TaskFactory factory = new TaskFactory(token);
      for (int taskCtr = 0; taskCtr <= 10; taskCtr++) {
         int iteration = taskCtr + 1;
         tasks.Add(factory.StartNew( () => {
                                       int value;
                                       int[] values = new int[10];
                                       for (int ctr = 1; ctr <= 10; ctr++) {
                                          lock (lockObj) {
                                             value = rnd.Next(0,101);
                                          }
                                          if (value == 0) { 
                                             source.Cancel();
                                             Console.WriteLine("Cancelling at task {0}", iteration);
                                             break;
                                          }   
                                          values[ctr-1] = value; 
                                       }
                                       return values;
                                    }, token));   

      }
      try {
         Task<double> fTask = factory.ContinueWhenAll(tasks.ToArray(), 
                                                      (results) => {
                                                         Console.WriteLine("Calculating overall mean...");
                                                         long sum = 0;
                                                         int n = 0; 
                                                         foreach (var t in results) {
                                                            foreach (var r in t.Result) {
                                                                  sum += r;
                                                                  n++;
                                                               }
                                                         }
                                                         return sum/(double) n;
                                                      } , token);
         Console.WriteLine("The mean is {0}.", fTask.Result);
      }   
      catch (AggregateException ae) {
         foreach (Exception e in ae.InnerExceptions) {
            if (e is TaskCanceledException)
               Console.WriteLine("Unable to compute mean: {0}", 
                                 ((TaskCanceledException) e).Message);
            else
               Console.WriteLine("Exception: " + e.GetType().Name);
         }
      }
      finally {
         source.Dispose();
      }
   }
}
4

2 回答 2

3

由于 .Net 中的取消是合作传递的CancellationToken，Task.Run例如，不足以确保任务被取消。

将令牌作为参数传递只会将令牌与任务相关联。只有在令牌被取消之前它没有机会开始运行时，它才能取消任务。例如：

var token = new CancellationToken(true); // creates a cancelled token
Task.Run(() => {}, token);

要在“飞行中”取消任务，您需要任务本身观察令牌并在发出取消信号时抛出，类似于：

Task.Run(() => 
{
    while (true)
    {
        token.ThrowIfCancellationRequested();
        // do something
    }
}, token);

此外，简单地从任务内部抛出异常只会将任务标记为Faulted. 将其标记为Cancelled 需要TaskCanceledException.CancellationToken匹配传递给的令牌Task.Run。

于 2015-10-26T09:48:52.030 回答
0

在找到这个问题之前，我正要问一个类似的问题。i3arnon 的答案是有道理的，但我会添加这个答案作为补充，希望能帮助别人。

我首先要说（与对已接受答案的评论相反）微软在 MSDN 上的例子是可怕的。除非您已经知道取消是如何工作的，否则它们不会对您有太大帮助。这篇 MSDN 文章向您展示了如何将 a 传递CancellationToken给 a，Task但如果您按照示例进行操作，它们实际上从未向您展示如何取消您自己当前正在执行的Task. CancellationToken只是消失在 Microsoft 代码中：

  • await client.GetAsync("http://msdn.microsoft.com/en-us/library/dd470362.aspx", ct);
  • await response.Content.ReadAsByteArrayAsync();

以下是我如何使用的示例CancellationToken：

当我有一项需要不断重复的任务时：

public class Foo
{
    private CancellationTokenSource _cts;

    public Foo()
    {
        this._cts = new CancellationTokenSource();
    }

    public void StartExecution()
    {
        Task.Factory.StartNew(this.OwnCodeCancelableTask, this._cts.Token);
        Task.Factory.StartNew(this.OwnCodeCancelableTask_EveryNSeconds, this._cts.Token);
    }

    public void CancelExecution()
    {
        this._cts.Cancel();
    }

    /// <summary>
    /// "Infinite" loop with no delays. Writing to a database while pulling from a buffer for example.
    /// </summary>
    /// <param name="taskState">The cancellation token from our _cts field, passed in the StartNew call</param>
    private void OwnCodeCancelableTask(object taskState)
    {
        var token = (CancellationToken) taskState;

        while ( !token.IsCancellationRequested )
        {
            Console.WriteLine("Do your task work in this loop");
        }
    }


    /// <summary>
    /// "Infinite" loop that runs every N seconds. Good for checking for a heartbeat or updates.
    /// </summary>
    /// <param name="taskState">The cancellation token from our _cts field, passed in the StartNew call</param>
    private async void OwnCodeCancelableTask_EveryNSeconds(object taskState)
    {
        var token = (CancellationToken)taskState;

        while (!token.IsCancellationRequested)
        {
            Console.WriteLine("Do the work that needs to happen every N seconds in this loop");

            // Passing token here allows the Delay to be cancelled if your task gets cancelled.
            await Task.Delay(1000 /*Or however long you want to wait.*/, token);
        }
    }
}

当我有用户可以启动的任务时：

public class Foo
{
    private CancellationTokenSource _cts;
    private Task _taskWeCanCancel;

    public Foo()
    {
        this._cts = new CancellationTokenSource();

        //This is where it's confusing. Passing the token here will only ensure that the task doesn't
        //run if it's canceled BEFORE it starts. This does not cancel the task during the operation of our code.
        this._taskWeCanCancel = new Task(this.FireTheTask, this._cts.Token);
    }
    /// <summary>
    /// I'm not a fan of returning tasks to calling code, so I keep this method void
    /// </summary>
    public void FireTheTask()
    {
        //Check task status here if it's required.
        this._taskWeCanCancel.Start();
    }

    public void CancelTheTask()
    {
        this._cts.Cancel();
    }

    /// <summary>
    /// Go and get something from the web, process a piece of data, execute a lengthy calculation etc...
    /// </summary>
    private async void OurTask()
    {
        Console.WriteLine("Do your work here and check periodically for task cancellation requests...");

        if (this._cts.Token.IsCancellationRequested) return;

        Console.WriteLine("Do another step to your work here then check the token again if necessary...");

        if (this._cts.Token.IsCancellationRequested) return;

        Console.WriteLine("Some work that we need to delegate to another task");

        await Some.Microsoft.Object.DoStuffAsync();
    }

}

也许我错过了 的一些关键特性Task，但是将CancellationTokenaTask作为 state 以外的任何东西传递给我对我来说从来没有多大意义。我还没有遇到过将 a 传递CancellationToken给 aTask并在它运行之前取消Task它的情况，即使我这样做了，我创建的每个任务的第一行总是

if (token.IsCancellationRequested) return;

于 2016-03-11T17:04:35.830 回答