.NET 4并行编程入门之Task的取消

查看本系列其他文章，请参看

为丛台等地区用户提供了全套网页设计制作服务，及丛台网站建设行业解决方案。主营业务为网站设计、成都网站建设、丛台网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

[[11687]]

因为Task是.NET 4并行编程最为核心的一个类，也我们在是在并行编程常常打交道的类，所以，对Task对全面的了解很有必要。

上篇文章主要讲述了如何创建一个task，本篇文章主要讲述如何取消一个task。

本篇主的主要议题如下：

1. 通过轮询的方式检测Task是否被取消

2.  用委托delegate来检测Task是否被取消

3. 用Wait Handle还检测Task是否被取消

4. 取消多个Task

5. 创建组合的取消Task的Token

6. 判断一个Task是否已经被取消了

本篇的理论不多，代码的例子很多。

在TPL中一个标准化的操作就是”取消Task”。之所以说它是个标准化的操作，其实是把这个操作和之前传统的多线程编程进行比较而言的。

在之前的多线程编程中，我们一般是自己写一些代码来取消线程的运行。但是在.NET 4的TPL中就内置了取消的方法，可能我们觉得TPL没有必要内置这些代码，因为太简单了。但是这个内置的方法不仅仅只是取消了运行的Task，而且还减小了在取消运行的Task时可能产生的一些风险，我们后续文章会详细讲述。

创建一个取消的Task一般要进行下面一些步骤：

a.创建System.Threading.CancellationTokenSource的一个实例：

 
 
 
      
  
  
  1. // create the cancellation token source  
    2.   
  
  
  2. ancellationTokenSource tokenSource = new CancellationTokenSource(); 
    3.

b.通过CancellationTokenSource.Token属性获得一个System.Threading.CancellationToken:

 
 
 
      
  
  
  1. CancellationToken token = tokenSource.Token; 
    2.

c.创建一个新的Task或者Task，并且在构造函数传入Action或者Action的委托作为***个参数，传入CancellationToken作为第二个参数：

 
 
 
      
  
  
  1. Task task = new Task(new Action(printMessage), token); 
    2.

d.调用Task的Start()方法。

上面的步骤和我们之前介绍的创建一个Task的代码几乎一样，只是在构造函数中多传入了一个参数。

如果想要取消一个Task的运行，只要调用CancellationToken实例的Cancel()方法就可以了。

有点要特别注意的，当我们调用了Cancel()方法之后，.NET Framework不会强制性的去关闭运行的Task。

我们自己必须去检测之前在创建Task时候传入的那个CancellationToken。

我们在创建Task是传入CancellationToken到构造函数，其实这个CancellationToken就是.NET Framework用来避免我们再次运行已经被取消的Task，可以说就是一个标志位。

首先，进入***个议题：

1.通过轮询的方式检测Task是否被取消

在很多Task内部都包含了循环，用来处理数据。我们可以在循环中通过CancellationToken的IsCancellationRequest属性来检测task是否被取消了。如果这个属性为true，那么我们就得跳出循环，并且释放task所占用的资源(如数据库资源，文件资源等).

我们也可以在task运行体中抛出System.Threading.OperationCanceledException来取消运行的task。

代码如下：

代码

 
 
 
      
  
  
  1. while (true)  
    2.   
  
  
  2. {  
    3.   
  
  
  3.     if (token.IsCancellationRequested)  
    4.   
  
  
  4.     {  
    5.   
  
  
  5.           // tidy up and release resources  
    6.   
  
  
  6.            throw new OperationCanceledException(token);  
    7.   
  
  
  7.     }  
    8.   
  
  
  8.      else 
    9.   
  
  
  9.      {  
    10.   
  
  
  10.         // do a unit of work  
    11.   
  
  
  11.        }  
    12.   
  
  
  12.  } 
    13.

如果我们没有任何的资源要释放，那么只要简单的调用CancellationToken.ThrowIfCancellationRequested()方法，这个方法会检查是否要取消task，并且抛出异常。代码如下：

 
 
 
      
  
  
  1. while (true)  
    2.   
  
  
  2.  
    3.   
  
  
  3.        token.ThrowIfCancellationRequested();  
    4.   
  
  
  4.         // do a unit of work  
    5.   
  
  
  5. } 
    6.

下面就给出有一个完整的例子：创建一个可以取消的task，并且通过轮询不断的检查是否要取消task

代码如下：

代码     

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.         {  
    3.   
  
  
  3.             // create the cancellation token source  
    4.   
  
  
  4.             CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.  
    6.   
  
  
  6.             // create the cancellation token  
    7.   
  
  
  7.             CancellationToken token = tokenSource.Token;  
    8.   
  
  
  8.             // create the task  
    9.   
  
  
  9.  
    10.   
  
  
  10.             Task task = new Task(() =>  
    11.   
  
  
  11.             {  
    12.   
  
  
  12.                 for (int i = 0; i < int.MaxValue; i++)  
    13.   
  
  
  13.                 {  
    14.   
  
  
  14.                     if (token.IsCancellationRequested)  
    15.   
  
  
  15.                     {  
    16.   
  
  
  16.                         Console.WriteLine("Task cancel detected");  
    17.   
  
  
  17.                         throw new OperationCanceledException(token);  
    18.   
  
  
  18.                     }  
    19.   
  
  
  19.                     else 
    20.   
  
  
  20.                     {  
    21.   
  
  
  21.                         Console.WriteLine("Int value {0}", i);  
    22.   
  
  
  22.                     }  
    23.   
  
  
  23.                 }  
    24.   
  
  
  24.             }, token);  
    25.   
  
  
  25.  
    26.   
  
  
  26.             // wait for input before we start the task  
    27.   
  
  
  27.             Console.WriteLine("Press enter to start task");  
    28.   
  
  
  28.             Console.WriteLine("Press enter again to cancel task");  
    29.   
  
  
  29.             Console.ReadLine();  
    30.   
  
  
  30.  
    31.   
  
  
  31.             // start the task  
    32.   
  
  
  32.             task.Start();  
    33.   
  
  
  33.  
    34.   
  
  
  34.             // read a line from the console.  
    35.   
  
  
  35.             Console.ReadLine();  
    36.   
  
  
  36.  
    37.   
  
  
  37.             // cancel the task  
    38.   
  
  
  38.             Console.WriteLine("Cancelling task");  
    39.   
  
  
  39.             tokenSource.Cancel();  
    40.   
  
  
  40.  
    41.   
  
  
  41.             // wait for input before exiting  
    42.   
  
  
  42.             Console.WriteLine("Main method complete. Press enter to finish.");  
    43.   
  
  
  43.             Console.ReadLine();  
    44.   
  
  
  44.         } 
    45.

2.       用委托delegate来检测Task是否被取消

我们可以在注册一个委托到CancellationToken中，这个委托的方法在CancellationToken.Cancel()调用之前被调用。

我们可以用这个委托中的方法来作为一个检测task是否被取消的另外一个可选的方法，因为这个方法是在Cancel()方法被调用之前就调用的，所以这个委托中的方法可以检测task是否被cancel了，也就是说，只要这个委托的方法被调用，那么就说这个CancellationToken.Cancel()方法被调用了，而且在这个委托的方法中我们可以做很多的事情，如通知用户取消操作发生了。

下面的代码给出了一个例子。

代码     

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.         {  
    3.   
  
  
  3.             // create the cancellation token source  
    4.   
  
  
  4.             CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.  
    6.   
  
  
  6.             // create the cancellation token  
    7.   
  
  
  7.             CancellationToken token = tokenSource.Token;  
    8.   
  
  
  8.  
    9.   
  
  
  9.             // create the task  
    10.   
  
  
  10.             Task task = new Task(() =>  
    11.   
  
  
  11.             {  
    12.   
  
  
  12.                 for (int i = 0; i < int.MaxValue; i++)  
    13.   
  
  
  13.                 {  
    14.   
  
  
  14.                     if (token.IsCancellationRequested)  
    15.   
  
  
  15.                     {  
    16.   
  
  
  16.                         Console.WriteLine("Task cancel detected");  
    17.   
  
  
  17.                         throw new OperationCanceledException(token);  
    18.   
  
  
  18.                     }  
    19.   
  
  
  19.                     else 
    20.   
  
  
  20.                     {  
    21.   
  
  
  21.                         Console.WriteLine("Int value {0}", i);  
    22.   
  
  
  22.                     }  
    23.   
  
  
  23.                 }  
    24.   
  
  
  24.             }, token);  
    25.   
  
  
  25.  
    26.   
  
  
  26.             // register a cancellation delegate  
    27.   
  
  
  27.             token.Register(() =>  
    28.   
  
  
  28.             {  
    29.   
  
  
  29.                 Console.WriteLine(">>>>>> Delegate Invoked\n");  
    30.   
  
  
  30.             });  
    31.   
  
  
  31.  
    32.   
  
  
  32.             // wait for input before we start the task  
    33.   
  
  
  33.             Console.WriteLine("Press enter to start task");  
    34.   
  
  
  34.             Console.WriteLine("Press enter again to cancel task");  
    35.   
  
  
  35.             Console.ReadLine();  
    36.   
  
  
  36.  
    37.   
  
  
  37.             // start the task  
    38.   
  
  
  38.             task.Start();  
    39.   
  
  
  39.             // read a line from the console.  
    40.   
  
  
  40.             Console.ReadLine();  
    41.   
  
  
  41.  
    42.   
  
  
  42.             // cancel the task  
    43.   
  
  
  43.             Console.WriteLine("Cancelling task");  
    44.   
  
  
  44.             tokenSource.Cancel();  
    45.   
  
  
  45.  
    46.   
  
  
  46.             // wait for input before exiting  
    47.   
  
  
  47.             Console.WriteLine("Main method complete. Press enter to finish.");  
    48.   
  
  
  48.             Console.ReadLine();  
    49.   
  
  
  49.         } 
    50.

3.       用Wait Handle还检测Task是否被取消

第三种方法检测task是否被cancel就是调用CancellationToken.WaitHandle属性。对于这个属性的详细使用，在后续的文章中会深入的讲述，在这里主要知道一点就行了：CancellationToken的WaitOne()方法会阻止task的运行，只有CancellationToken的cancel()方法被调用后，这种阻止才会释放。

在下面的例子中，创建了两个task，其中task2调用了WaitOne()方法，所以task2一直不会运行，除非调用了CancellationToken的Cancel()方法，所以WaitOne()方法也算是检测task是否被cancel的一种方法了。

代码     

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.        {  
    3.   
  
  
  3.  
    4.   
  
  
  4.            // create the cancellation token source  
    5.   
  
  
  5.            CancellationTokenSource tokenSource = new CancellationTokenSource();  
    6.   
  
  
  6.  
    7.   
  
  
  7.            // create the cancellation token  
    8.   
  
  
  8.            CancellationToken token = tokenSource.Token;  
    9.   
  
  
  9.  
    10.   
  
  
  10.            // create the task  
    11.   
  
  
  11.            Task task1 = new Task(() =>  
    12.   
  
  
  12.            {  
    13.   
  
  
  13.                for (int i = 0; i < int.MaxValue; i++)  
    14.   
  
  
  14.                {  
    15.   
  
  
  15.                    if (token.IsCancellationRequested)  
    16.   
  
  
  16.                    {  
    17.   
  
  
  17.                        Console.WriteLine("Task cancel detected");  
    18.   
  
  
  18.                        throw new OperationCanceledException(token);  
    19.   
  
  
  19.                    }  
    20.   
  
  
  20.                    else 
    21.   
  
  
  21.                    {  
    22.   
  
  
  22.                        Console.WriteLine("Int value {0}", i);  
    23.   
  
  
  23.                    }  
    24.   
  
  
  24.                }  
    25.   
  
  
  25.            }, token);  
    26.   
  
  
  26.  
    27.   
  
  
  27.            // create a second task that will use the wait handle  
    28.   
  
  
  28.            Task task2 = new Task(() =>  
    29.   
  
  
  29.            {  
    30.   
  
  
  30.                // wait on the handle  
    31.   
  
  
  31.                token.WaitHandle.WaitOne();  
    32.   
  
  
  32.                // write out a message  
    33.   
  
  
  33.                Console.WriteLine(">>>>> Wait handle released");  
    34.   
  
  
  34.            });  
    35.   
  
  
  35.  
    36.   
  
  
  36.            // wait for input before we start the task  
    37.   
  
  
  37.            Console.WriteLine("Press enter to start task");  
    38.   
  
  
  38.            Console.WriteLine("Press enter again to cancel task");  
    39.   
  
  
  39.            Console.ReadLine();  
    40.   
  
  
  40.            // start the tasks  
    41.   
  
  
  41.            task1.Start();  
    42.   
  
  
  42.            task2.Start();  
    43.   
  
  
  43.  
    44.   
  
  
  44.            // read a line from the console.  
    45.   
  
  
  45.            Console.ReadLine();  
    46.   
  
  
  46.  
    47.   
  
  
  47.            // cancel the task  
    48.   
  
  
  48.            Console.WriteLine("Cancelling task");  
    49.   
  
  
  49.            tokenSource.Cancel();  
    50.   
  
  
  50.  
    51.   
  
  
  51.            // wait for input before exiting  
    52.   
  
  
  52.            Console.WriteLine("Main method complete. Press enter to finish.");  
    53.   
  
  
  53.            Console.ReadLine();  
    54.   
  
  
  54.        } 
    55.

4.      取消多个Task

我们可以使用一个CancellationToken来创建多个不同的Tasks，当这个CancellationToken的Cancel()方法调用的时候，使用了这个token的多个task都会被取消。

代码     

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.         {  
    3.   
  
  
  3.             // create the cancellation token source  
    4.   
  
  
  4.             CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.  
    6.   
  
  
  6.             // create the cancellation token  
    7.   
  
  
  7.             CancellationToken token = tokenSource.Token;  
    8.   
  
  
  8.  
    9.   
  
  
  9.             // create the tasks  
    10.   
  
  
  10.             Task task1 = new Task(() =>  
    11.   
  
  
  11.             {  
    12.   
  
  
  12.                 for (int i = 0; i < int.MaxValue; i++)  
    13.   
  
  
  13.                 {  
    14.   
  
  
  14.                     token.ThrowIfCancellationRequested();  
    15.   
  
  
  15.                     Console.WriteLine("Task 1 - Int value {0}", i);  
    16.   
  
  
  16.                 }  
    17.   
  
  
  17.             }, token);  
    18.   
  
  
  18.  
    19.   
  
  
  19.             Task task2 = new Task(() =>  
    20.   
  
  
  20.             {  
    21.   
  
  
  21.                 for (int i = 0; i < int.MaxValue; i++)  
    22.   
  
  
  22.                 {  
    23.   
  
  
  23.                     token.ThrowIfCancellationRequested();  
    24.   
  
  
  24.                     Console.WriteLine("Task 2 - Int value {0}", i);  
    25.   
  
  
  25.                 }  
    26.   
  
  
  26.             }, token);  
    27.   
  
  
  27.             // wait for input before we start the tasks  
    28.   
  
  
  28.             Console.WriteLine("Press enter to start tasks");  
    29.   
  
  
  29.             Console.WriteLine("Press enter again to cancel tasks");  
    30.   
  
  
  30.             Console.ReadLine();  
    31.   
  
  
  31.  
    32.   
  
  
  32.             // start the tasks  
    33.   
  
  
  33.             task1.Start();  
    34.   
  
  
  34.             task2.Start();  
    35.   
  
  
  35.  
    36.   
  
  
  36.             // read a line from the console.  
    37.   
  
  
  37.             Console.ReadLine();  
    38.   
  
  
  38.  
    39.   
  
  
  39.             // cancel the task  
    40.   
  
  
  40.             Console.WriteLine("Cancelling tasks");  
    41.   
  
  
  41.             tokenSource.Cancel();  
    42.   
  
  
  42.             // wait for input before exiting  
    43.   
  
  
  43.             Console.WriteLine("Main method complete. Press enter to finish.");  
    44.   
  
  
  44.             Console.ReadLine();  
    45.   
  
  
  45.         } 
    46.

5. 创建组合的取消Task的Token

我们可以用CancellationTokenSource.CreateLinkedTokenSource()方法来创建一个组合的token，这个组合的token有很多的CancellationToken组成。主要组合token中的任意一个token调用了Cancel()方法，那么使用这个组合token的所有task就会被取消。代码如下：

代码     

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.        {  
    3.   
  
  
  3.            // create the cancellation token sources  
    4.   
  
  
  4.            CancellationTokenSource tokenSource1 = new CancellationTokenSource();  
    5.   
  
  
  5.            CancellationTokenSource tokenSource2 = new CancellationTokenSource();  
    6.   
  
  
  6.            CancellationTokenSource tokenSource3 = new CancellationTokenSource();  
    7.   
  
  
  7.  
    8.   
  
  
  8.            // create a composite token source using multiple tokens  
    9.   
  
  
  9.            CancellationTokenSource compositeSource =   
    10.   
  
  
  10.                CancellationTokenSource.CreateLinkedTokenSource(  
    11.   
  
  
  11.            tokenSource1.Token, tokenSource2.Token, tokenSource3.Token);  
    12.   
  
  
  12.  
    13.   
  
  
  13.            // create a cancellable task using the composite token  
    14.   
  
  
  14.            Task task = new Task(() =>  
    15.   
  
  
  15.            {  
    16.   
  
  
  16.                // wait until the token has been cancelled  
    17.   
  
  
  17.                compositeSource.Token.WaitHandle.WaitOne();  
    18.   
  
  
  18.                // throw a cancellation exception  
    19.   
  
  
  19.                throw new OperationCanceledException(compositeSource.Token);  
    20.   
  
  
  20.            }, compositeSource.Token);  
    21.   
  
  
  21.  
    22.   
  
  
  22.            // start the task  
    23.   
  
  
  23.            task.Start();  
    24.   
  
  
  24.  
    25.   
  
  
  25.            // cancel one of the original tokens  
    26.   
  
  
  26.            tokenSource2.Cancel();  
    27.   
  
  
  27.  
    28.   
  
  
  28.            // wait for input before exiting  
    29.   
  
  
  29.            Console.WriteLine("Main method complete. Press enter to finish.");  
    30.   
  
  
  30.            Console.ReadLine();  
    31.   
  
  
  31.        } 
    32.

6.      判断一个Task是否已经被取消了

可以使用Task的IsCancelled属性来判断task是否被取消了。代码如下：

代码     

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.        {  
    3.   
  
  
  3.            // create the cancellation token source  
    4.   
  
  
  4.            CancellationTokenSource tokenSource1 = new CancellationTokenSource();  
    5.   
  
  
  5.  
    6.   
  
  
  6.            // create the cancellation token  
    7.   
  
  
  7.            CancellationToken token1 = tokenSource1.Token;  
    8.   
  
  
  8.  
    9.   
  
  
  9.            // create the first task, which we will let run fully  
    10.   
  
  
  10.            Task task1 = new Task(() =>  
    11.   
  
  
  11.            {  
    12.   
  
  
  12.                for (int i = 0; i < 10; i++)  
    13.   
  
  
  13.                {  
    14.   
  
  
  14.                    token1.ThrowIfCancellationRequested();  
    15.   
  
  
  15.                    Console.WriteLine("Task 1 - Int value {0}", i);  
    16.   
  
  
  16.                }  
    17.   
  
  
  17.            }, token1);  
    18.   
  
  
  18.  
    19.   
  
  
  19.            // create the second cancellation token source  
    20.   
  
  
  20.            CancellationTokenSource tokenSource2 = new CancellationTokenSource();  
    21.   
  
  
  21.  
    22.   
  
  
  22.            // create the cancellation token  
    23.   
  
  
  23.            CancellationToken token2 = tokenSource2.Token;  
    24.   
  
  
  24.  
    25.   
  
  
  25.            // create the second task, which we will cancel  
    26.   
  
  
  26.            Task task2 = new Task(() =>  
    27.   
  
  
  27.            {  
    28.   
  
  
  28.                for (int i = 0; i < int.MaxValue; i++)  
    29.   
  
  
  29.                {  
    30.   
  
  
  30.                    token2.ThrowIfCancellationRequested();  
    31.   
  
  
  31.                    Console.WriteLine("Task 2 - Int value {0}", i);  
    32.   
  
  
  32.                }  
    33.   
  
  
  33.            }, token2);  
    34.   
  
  
  34.  
    35.   
  
  
  35.            // start all of the tasks  
    36.   
  
  
  36.            task1.Start();  
    37.   
  
  
  37.            task2.Start();  
    38.   
  
  
  38.  
    39.   
  
  
  39.            // cancel the second token source  
    40.   
  
  
  40.            tokenSource2.Cancel();  
    41.   
  
  
  41.            // write out the cancellation detail of each task  
    42.   
  
  
  42.            Console.WriteLine("Task 1 cancelled? {0}", task1.IsCanceled);  
    43.   
  
  
  43.            Console.WriteLine("Task 2 cancelled? {0}", task2.IsCanceled);  
    44.   
  
  
  44.            // wait for input before exiting  
    45.   
  
  
  45.            Console.WriteLine("Main method complete. Press enter to finish.");  
    46.   
  
  
  46.            Console.ReadLine();  
    47.   
  
  
  47.        } 
    48.

分享文章：.NET 4并行编程入门之Task的取消
文章源于：http://www.shufengxianlan.com/qtweb/news13/532163.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

手机网站建设知识

同城分类信息

成都网站建设　　 　成都水电改造　　 　成都温江机房　　 　网站SEO优化　　 　攀枝花网站建设　　 　成都铺面装修　　 　边坡防护网　　 　手机网站制作设计　　 　中建建业环保　　 　成都多线机房　　 　申请域名　　 　ssl数字证书　　 　成都app软件开发　　 　托管服务器　　 　外贸网站建设方案　　 　香港云主机　　 　成都网站设计　　 　宜宾网站建设　　 　手机网站设计　　 　手机网站制作