.NET4并行编程入门之Task执行和异常处理

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

创新互联是一家专业提供永年企业网站建设,专注与成都网站制作、网站建设、外贸网站建设、H5响应式网站、小程序制作等业务。10年已为永年众多企业、政府机构等服务。创新互联专业网络公司优惠进行中。

[[11782]]

本篇主要讲述等待task执行完成。

本篇的议题如下：

1. 等待Task执行完成

2. Task中的异常处理

首先注意一点：这里提到的"等待"和之前文章提到的"休眠"意思是不一样的：

等待：在等待一个task的时候，这个task还是在运行之中的，"等待"相当于在监听运行的task的执行情况。

休眠：让tasku不运行。

在上篇文章中介绍了如果从Task中获取执行后的结果：在Task执行完成之后调用Task.Result获取。其实也可以用其他的方法等待Task执行完成而不获取结果，这是很有用的：如果你想等待一个task完成之后再去做其他的事情。而且我们还可以等待一个task执行完成，或者等待所有的task执行完成，或者等待很多task中的一个执行完成。因为Task是由内部的Scheduler管理的，调用wait方法，其实就是我们在监控task的执行，看看这个task是否执行完了，如果完成，那么wanit方法就返回true，反之。

1. 等待Task执行完成

1.1等待单独的一个Task执行完成

我们可以用Wait()方法来一直等待一个Task执行完成。当task执行完成，或者被cancel，或者抛出异常，这个方法才会返回。可以使用Wait()方法的不同重载。举个例子：

代码

 
 
 
    
  
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.         // create the cancellation token source  
    4.   
  
  
  4.         CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.         // create the cancellation token  
    6.   
  
  
  6.         CancellationToken token = tokenSource.Token;  
    7.   
  
  
  7.         // create and start the first task, which we will let run fully  
    8.   
  
  
  8.         Task task = createTask(token);  
    9.   
  
  
  9.         task.Start();  
    10.   
  
  
  10.  
    11.   
  
  
  11.         // wait for the task  
    12.   
  
  
  12.         Console.WriteLine("Waiting for task to complete.");  
    13.   
  
  
  13.         task.Wait();  
    14.   
  
  
  14.         Console.WriteLine("Task Completed.");  
    15.   
  
  
  15.  
    16.   
  
  
  16.         // create and start another task  
    17.   
  
  
  17.         task = createTask(token);  
    18.   
  
  
  18.         task.Start();  
    19.   
  
  
  19.         Console.WriteLine("Waiting 2 secs for task to complete.");  
    20.   
  
  
  20.         bool completed = task.Wait(2000);  
    21.   
  
  
  21.         Console.WriteLine("Wait ended - task completed: {0}", completed);  
    22.   
  
  
  22.  
    23.   
  
  
  23.         // create and start another task  
    24.   
  
  
  24.         task = createTask(token);  
    25.   
  
  
  25.         task.Start();  
    26.   
  
  
  26.         Console.WriteLine("Waiting 2 secs for task to complete.");  
    27.   
  
  
  27.         completed = task.Wait(2000, token);  
    28.   
  
  
  28.         Console.WriteLine("Wait ended - task completed: {0} task cancelled {1}",  
    29.   
  
  
  29.         completed, task.IsCanceled);  
    30.   
  
  
  30.  
    31.   
  
  
  31.         // wait for input before exiting  
    32.   
  
  
  32.         Console.WriteLine("Main method complete. Press enter to finish.");  
    33.   
  
  
  33.         Console.ReadLine();  
    34.   
  
  
  34.     }  
    35.   
  
  
  35.  
    36.   
  
  
  36.     static Task createTask(CancellationToken token)  
    37.   
  
  
  37.     {  
    38.   
  
  
  38.         return new Task(() =>  
    39.   
  
  
  39.         {  
    40.   
  
  
  40.             for (int i = 0; i < 5; i++)  
    41.   
  
  
  41.             {  
    42.   
  
  
  42.                 // check for task cancellation  
    43.   
  
  
  43.                 token.ThrowIfCancellationRequested();  
    44.   
  
  
  44.                 // print out a message  
    45.   
  
  
  45.                 Console.WriteLine("Task - Int value {0}", i);  
    46.   
  
  
  46.                 // put the task to sleep for 1 second  
    47.   
  
  
  47.                 token.WaitHandle.WaitOne(1000);  
    48.   
  
  
  48.             }  
    49.   
  
  
  49.         }, token);  
    50.   
  
  
  50.     } 
    51.

从上面的例子可以看出，wait方法子task执行完成之后会返回true。

注意：当在执行的task内部抛出了异常之后，这个异常在调用wait方法时会被再次抛出。后面再"异常处理篇"会讲述。

1.2.等待多个task

我们也可以用WaitAll()方法来一直到等待多个task执行完成。只有当所有的task执行完成，或者被cancel，或者抛出异常，这个方法才会返回。WiatAll()方法和Wait()方法一样有一些重载。

注意：如果在等在的多个task之中，有一个task抛出了异常，那么调用WaitAll()方法时就会抛出异常。

代码

 
 
 
    
  
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.         // create the cancellation token source  
    4.   
  
  
  4.         CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.         // create the cancellation token  
    6.   
  
  
  6.         CancellationToken token = tokenSource.Token;  
    7.   
  
  
  7.         // create the tasks  
    8.   
  
  
  8.         Task task1 = new Task(() =>  
    9.   
  
  
  9.         {  
    10.   
  
  
  10.             for (int i = 0; i < 5; i++)  
    11.   
  
  
  11.             {  
    12.   
  
  
  12.                 // check for task cancellation  
    13.   
  
  
  13.                 token.ThrowIfCancellationRequested();  
    14.   
  
  
  14.                 // print out a message  
    15.   
  
  
  15.                 Console.WriteLine("Task 1 - Int value {0}", i);  
    16.   
  
  
  16.                 // put the task to sleep for 1 second  
    17.   
  
  
  17.                 token.WaitHandle.WaitOne(1000);  
    18.   
  
  
  18.             }  
    19.   
  
  
  19.             Console.WriteLine("Task 1 complete");  
    20.   
  
  
  20.         }, token);  
    21.   
  
  
  21.         Task task2 = new Task(() =>  
    22.   
  
  
  22.         {  
    23.   
  
  
  23.             Console.WriteLine("Task 2 complete");  
    24.   
  
  
  24.         }, token);  
    25.   
  
  
  25.  
    26.   
  
  
  26.         // start the tasks  
    27.   
  
  
  27.         task1.Start();  
    28.   
  
  
  28.         task2.Start();  
    29.   
  
  
  29.         // wait for the tasks  
    30.   
  
  
  30.         Console.WriteLine("Waiting for tasks to complete.");  
    31.   
  
  
  31.         Task.WaitAll(task1, task2);  
    32.   
  
  
  32.         Console.WriteLine("Tasks Completed.");  
    33.   
  
  
  33.         // wait for input before exiting  
    34.   
  
  
  34.         Console.WriteLine("Main method complete. Press enter to finish.");  
    35.   
  
  
  35.         Console.ReadLine();  
    36.   
  
  
  36.     } 
    37.

 在上面的例子中，首先创建了两个task，注意我们创建的是可以被cancel的task，因为使用CancellationToken。而且在***个task中还是用waitOne()休眠方法，其实目的很简单：使得这个task的运行时间长一点而已。之后我们就调用了WaitAll()方法，这个方法一直到两个task执行完成之后才会返回的。

1.3.等待多个task中的一个task执行完成

可以用WaitAny()方法来等待多个task中的一个task执行完成。通俗的讲就是：有很多的task在运行，调用了WaitAny()方法之后，只要那些运行的task其中有一个运行完成了，那么WaitAny()就返回了。

代码

 
 
 
    
  
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.         // create the cancellation token source  
    4.   
  
  
  4.         CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.         // create the cancellation token  
    6.   
  
  
  6.         CancellationToken token = tokenSource.Token;  
    7.   
  
  
  7.         // create the tasks  
    8.   
  
  
  8.         Task task1 = new Task(() =>  
    9.   
  
  
  9.         {  
    10.   
  
  
  10.             for (int i = 0; i < 5; i++)  
    11.   
  
  
  11.             {  
    12.   
  
  
  12.                 // check for task cancellation  
    13.   
  
  
  13.                 token.ThrowIfCancellationRequested();  
    14.   
  
  
  14.                 // print out a message  
    15.   
  
  
  15.                 Console.WriteLine("Task 1 - Int value {0}", i);  
    16.   
  
  
  16.                 // put the task to sleep for 1 second  
    17.   
  
  
  17.                 token.WaitHandle.WaitOne(1000);  
    18.   
  
  
  18.             }  
    19.   
  
  
  19.             Console.WriteLine("Task 1 complete");  
    20.   
  
  
  20.         }, token);  
    21.   
  
  
  21.         Task task2 = new Task(() =>  
    22.   
  
  
  22.         {  
    23.   
  
  
  23.             Console.WriteLine("Task 2 complete");  
    24.   
  
  
  24.         }, token);  
    25.   
  
  
  25.  
    26.   
  
  
  26.         // start the tasks  
    27.   
  
  
  27.         task1.Start();  
    28.   
  
  
  28.         task2.Start();  
    29.   
  
  
  29.         // wait for the tasks  
    30.   
  
  
  30.         Console.WriteLine("Waiting for tasks to complete.");  
    31.   
  
  
  31.         Task.WaitAll(task1, task2);  
    32.   
  
  
  32.         Console.WriteLine("Tasks Completed.");  
    33.   
  
  
  33.         // wait for input before exiting  
    34.   
  
  
  34.         Console.WriteLine("Main method complete. Press enter to finish.");  
    35.   
  
  
  35.         Console.ReadLine();  
    36.   
  
  
  36.     } 
    37.

2. Task中的异常处理

在并行编程(TPL)中另外一个已经标准化了的操作就是"异常处理"。而且在并行编程中异常处理显得尤为重要，因为并行编程时与系统中的线程相关的，出了异常，你开发的程序就很有可能崩溃。

下面就详细介绍TPL中异常处理操作。

 a.处理基本的异常。

 在操作task的时候，只要出现了异常，.NET Framework就会把这些异常记录下来。例如在执行Task.Wait(),Task.WaitAll(),Task.WaitAny(),Task.Result.不管那里出现了异常，***抛出的就是一个System.AggregateException.

 System.AggregateException时用来包装一个或者多个异常的，这个类时很有用的，特别是在调用Task.WaitAll()方法时。因为在Task.WaitAll()是等待多个task执行完成，如果有任意task执行出了异常，那么这个异常就会被记录在System.AggregateException中，不同的task可能抛出的异常不同，但是这些异常都会被记录下来。

下面就是给出一个例子：在例子中，创建了两个task，它们都抛出异常。然后主线程开始运行task，并且调用WaitAll()方法，然后就捕获抛出的System.AggregateException,显示详细信息。

代码

 
 
 
    
  
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.  
    4.   
  
  
  4.         // create the tasks  
    5.   
  
  
  5.         Task task1 = new Task(() =>  
    6.   
  
  
  6.         {  
    7.   
  
  
  7.             ArgumentOutOfRangeException exception = new ArgumentOutOfRangeException();  
    8.   
  
  
  8.             exception.Source = "task1";  
    9.   
  
  
  9.             throw exception;  
    10.   
  
  
  10.         });  
    11.   
  
  
  11.         Task task2 = new Task(() =>  
    12.   
  
  
  12.         {  
    13.   
  
  
  13.             throw new NullReferenceException();  
    14.   
  
  
  14.         });  
    15.   
  
  
  15.         Task task3 = new Task(() =>  
    16.   
  
  
  16.         {  
    17.   
  
  
  17.             Console.WriteLine("Hello from Task 3");  
    18.   
  
  
  18.         });  
    19.   
  
  
  19.         // start the tasks  
    20.   
  
  
  20.         task1.Start(); task2.Start(); task3.Start();  
    21.   
  
  
  21.         // wait for all of the tasks to complete  
    22.   
  
  
  22.         // and wrap the method in a try...catch block  
    23.   
  
  
  23.         try 
    24.   
  
  
  24.         {  
    25.   
  
  
  25.             Task.WaitAll(task1, task2, task3);  
    26.   
  
  
  26.         }  
    27.   
  
  
  27.         catch (AggregateException ex)  
    28.   
  
  
  28.         {  
    29.   
  
  
  29.             // enumerate the exceptions that have been aggregated  
    30.   
  
  
  30.             foreach (Exception inner in ex.InnerExceptions)  
    31.   
  
  
  31.             {  
    32.   
  
  
  32.                 Console.WriteLine("Exception type {0} from {1}",  
    33.   
  
  
  33.                 inner.GetType(), inner.Source);  
    34.   
  
  
  34.             }  
    35.   
  
  
  35.         }  
    36.   
  
  
  36.         // wait for input before exiting  
    37.   
  
  
  37.         Console.WriteLine("Main method complete. Press enter to finish.");  
    38.   
  
  
  38.         Console.ReadLine();  
    39.   
  
  
  39.     } 
    40.

　

　从上面的例子可以看出，为了获得被包装起来的异常，需要调用System.AggregateException的InnerExceptions属性，这个属性返回一个异常的集合，然后就可以遍历这个集合。

而且从上面的例子可以看到：Exeception.Source属性被用来指明task1的异常时ArgumentOutRangeException.

 b.使用迭代的异常处理Handler

 一般情况下，我们需要区分哪些异常需要处理，而哪些异常需要继续往上传递。AggregateException类提供了一个Handle()方法，我们可以用这个方法来处理

AggregateException中的每一个异常。在这个Handle()方法中，返回true就表明，这个异常我们已经处理了，不用抛出，反之。

 在下面的例子中，抛出了一个OperationCancelException，在之前的task的取消一文中，已经提到过：当在task中抛出这个异常的时候，实际上就是这个task发送了取消的请求。下面的代码中，描述了如果在AggregateException.Handle()中处理不同的异常。

代码

 
 
 
    
  
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.     {  
    3.   
  
  
  3.         // create the cancellation token source and the token  
    4.   
  
  
  4.         CancellationTokenSource tokenSource = new CancellationTokenSource();  
    5.   
  
  
  5.         CancellationToken token = tokenSource.Token;  
    6.   
  
  
  6.         // create a task that waits on the cancellation token  
    7.   
  
  
  7.         Task task1 = new Task(() =>  
    8.   
  
  
  8.         {  
    9.   
  
  
  9.             // wait forever or until the token is cancelled  
    10.   
  
  
  10.             token.WaitHandle.WaitOne(-1);  
    11.   
  
  
  11.             // throw an exception to acknowledge the cancellation  
    12.   
  
  
  12.             throw new OperationCanceledException(token);  
    13.   
  
  
  13.         }, token);  
    14.   
  
  
  14.         // create a task that throws an exception  
    15.   
  
  
  15.         Task task2 = new Task(() =>  
    16.   
  
  
  16.         {  
    17.   
  
  
  17.             throw new NullReferenceException();  
    18.   
  
  
  18.         });  
    19.   
  
  
  19.         // start the tasks  
    20.   
  
  
  20.         task1.Start(); task2.Start();  
    21.   
  
  
  21.         // cancel the token  
    22.   
  
  
  22.         tokenSource.Cancel();  
    23.   
  
  
  23.         // wait on the tasks and catch any exceptions  
    24.   
  
  
  24.         try 
    25.   
  
  
  25.         {  
    26.   
  
  
  26.             Task.WaitAll(task1, task2);  
    27.   
  
  
  27.         }  
    28.   
  
  
  28.         catch (AggregateException ex)  
    29.   
  
  
  29.         {  
    30.   
  
  
  30.             // iterate through the inner exceptions using  
    31.   
  
  
  31.             // the handle method  
    32.   
  
  
  32.             ex.Handle((inner) =>  
    33.   
  
  
  33.             {  
    34.   
  
  
  34.                 if (inner is OperationCanceledException)  
    35.   
  
  
  35.                 {  
    36.   
  
  
  36.  
    37.   
  
  
  37.                     // ...handle task cancellation...  
    38.   
  
  
  38.                     return true;  
    39.   
  
  
  39.                 }  
    40.   
  
  
  40.                 else 
    41.   
  
  
  41.                 {  
    42.   
  
  
  42.                     // this is an exception we don't know how  
    43.   
  
  
  43.                     // to handle, so return false  
    44.   
  
  
  44.                     return false;  
    45.   
  
  
  45.                 }  
    46.   
  
  
  46.             });  
    47.   
  
  
  47.         }  
    48.   
  
  
  48.         // wait for input before exiting  
    49.   
  
  
  49.         Console.WriteLine("Main method complete. Press enter to finish.");  
    50.   
  
  
  50.         Console.ReadLine();  
    51.   
  
  
  51.     } 
    52.

 今天就写到这里。谢谢！

文章标题：.NET4并行编程入门之Task执行和异常处理
转载来源：http://www.shufengxianlan.com/qtweb/news23/103123.html

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

广告

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

猜你还喜欢下面的内容

品牌网站设计知识

各行业网站

西信中心　　 　企业官网建设　　 　堡垒主机　　 　网站排名　　 　重庆服务器托管　　 　成都富士康招工　　 　乐山石膏隔墙　　 　成都做网站　　 　自贡电信机房　　 　金融行业网站建设方案　　 　成都网站运营维护　　 　成都网站推广　　 　重庆网站建设网络公司　　 　成都免费网站建设公司　　 　成都营销网站建设　　 　绵阳网站建设公司　　 　网站定制　　 　网站建设方案　　 　专业网站建设　　 　高端网站设计