.NET 4并行编程之Task基础部分完结篇

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

成都一家集口碑和实力的网站建设服务商，拥有专业的企业建站团队和靠谱的建站技术，10年企业及个人网站建设经验 ,为成都近1000家客户提供网页设计制作,网站开发,企业网站制作建设等服务,包括成都营销型网站建设，品牌网站建设，同时也为不同行业的客户提供网站设计制作、成都网站设计的服务,包括成都电商型网站制作建设,装修行业网站制作建设，传统机械行业网站建设,传统农业行业网站制作建设。在成都做网站,选网站制作建设服务商就选创新互联公司。

[[11863]]

本篇的主要议题如下:

1.获取Task的状态

2.执行晚加载的Task(Lazily Task)

3.常见问题的解决方案

1.获取Task的状态

在.NET并行编程还有一个已经标准化的操作就是可以获取task的状态，通过Task.Status属性来得到的，这个属性返回一个System.Threading.Tasks.TaskStatus的枚举值。

如下：

Created:表明task已经被初始化了，但是还没有加入到Scheduler中。

WatingForActivation：task正在等待被加入到Scheduler中。

 WaitingToRun:已经被加入到了Scheduler，等待执行。

Running：task正在运行

WaitingForChildrenToComplete:表明父task正在等待子task运行结束。

RanToCompletion:表明task已经执行完了，但是还没有被cancel，而且也这个task也没有抛出异常。

Canceled:表明task已经被cancel了。（大家可以参看之前讲述取消task的文章）

Faulted:表明task在运行的时候已经抛出了异常。

2.执行晚加载的Task(Lazily Task)

晚加载，或者又名延迟初始化，主要的好处就是避免不必要的系统开销。在并行编程中，可以联合使用Lazy变量和Task<>.Factory.StartNew()做到这点。(Lazy变量时.NET 4中的一个新特性，这里大家不用知道Lazy的具体细节)

Lazy变量只有在用到的时候才会被初始化。所以我们可以把Lazy变量和task的创建结合：只有这个task要被执行的时候才去初始化。

下面还是通过例子来讲解：

代码 

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.        {  
    3.   
  
  
  3.            // define the function  
    4.   
  
  
  4.            Func taskBody = new Func(() =>  
    5.   
  
  
  5.            {  
    6.   
  
  
  6.                Console.WriteLine("Task body working...");  
    7.   
  
  
  7.                return "Task Result";  
    8.   
  
  
  8.            });  
    9.   
  
  
  9.  
    10.   
  
  
  10.            // create the lazy variable  
    11.   
  
  
  11.            Lazy> lazyData = new Lazy>(() =>  
    12.   
  
  
  12.            Task.Factory.StartNew(taskBody));  
    13.   
  
  
  13.  
    14.   
  
  
  14.            Console.WriteLine("Calling lazy variable");  
    15.   
  
  
  15.            Console.WriteLine("Result from task: {0}", lazyData.Value.Result);  
    16.   
  
  
  16.  
    17.   
  
  
  17.            // do the same thing in a single statement  
    18.   
  
  
  18.            Lazy> lazyData2 = new Lazy>(  
    19.   
  
  
  19.            () => Task.Factory.StartNew(() =>  
    20.   
  
  
  20.            {  
    21.   
  
  
  21.                Console.WriteLine("Task body working...");  
    22.   
  
  
  22.                return "Task Result";  
    23.   
  
  
  23.            }));  
    24.   
  
  
  24.  
    25.   
  
  
  25.            Console.WriteLine("Calling second lazy variable");  
    26.   
  
  
  26.            Console.WriteLine("Result from task: {0}", lazyData2.Value.Result);  
    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.

首先我们回想一下，在之前的系列文章中我们是怎么定义一个task的：直接new，或者通过task的factory来创建，因为创建task的代码是在main函数中的，所以只要new了一个task，那么这个task就被初始化。现在如果用了Lazy的task，那么现在我们初始化的就是那个Lazy变量了，而没有初始化task，(初始化Lazy变量的开销小于初始化task)，只有当调用了lazyData.Value时，Lazy变量中包含的那个task才会初始化。（这里欢迎大家提出自己的理解）

3.常见问题的解决方案

a.Task 死锁

描述：如果有两个或者多个task(简称TaskA)等待其他的task（TaskB）执行完成才开始执行，但是TaskB也在等待TaskA执行完成才开始执行，这样死锁就产生了。

解决方案：避免这个问题最好的方法就是：不要使的task来依赖其他的task。也就是说，最好不要你定义的task的执行体内包含其他的task。

例子：在下面的例子中，有两个task，他们相互依赖：他们都要使用对方的执行结果。当主程序开始运行之后，两个task也开始运行，但是因为两个task已经死锁了，所以主程序就一直等待。

代码

 
 
 
      
  
  
  1. static void Main(string[] args)  
    2.   
  
  
  2.         {  
    3.   
  
  
  3.             // define an array to hold the Tasks  
    4.   
  
  
  4.             Task[] tasks = new Task[2];  
    5.   
  
  
  5.  
    6.   
  
  
  6.             // create and start the first task  
    7.   
  
  
  7.             tasks[0] = Task.Factory.StartNew(() =>  
    8.   
  
  
  8.             {  
    9.   
  
  
  9.                 // get the result of the other task,  
    10.   
  
  
  10.                 // add 100 to it and return it as the result  
    11.   
  
  
  11.                 return tasks[1].Result + 100;  
    12.   
  
  
  12.             });  
    13.   
  
  
  13.  
    14.   
  
  
  14.             // create and start the second task  
    15.   
  
  
  15.             tasks[1] = Task.Factory.StartNew(() =>  
    16.   
  
  
  16.             {  
    17.   
  
  
  17.                 // get the result of the other task,  
    18.   
  
  
  18.                 // add 100 to it and return it as the result  
    19.   
  
  
  19.                 return tasks[1].Result + 100;  
    20.   
  
  
  20.             });  
    21.   
  
  
  21.  
    22.   
  
  
  22.  
    23.   
  
  
  23.             // wait for the tasks to complete  
    24.   
  
  
  24.             Task.WaitAll(tasks);  
    25.   
  
  
  25.  
    26.   
  
  
  26.             // wait for input before exiting  
    27.   
  
  
  27.             Console.WriteLine("Main method complete. Press enter to finish.");  
    28.   
  
  
  28.             Console.ReadLine();  
    29.   
  
  
  29.         } 
    30.

本篇就到这里了，很短，基础的部分就基本介绍完了，后面的文章就开始讲述应用。

本文名称：.NET 4并行编程之Task基础部分完结篇
链接URL：http://www.gawzjz.com/qtweb2/news1/6151.html

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

广告

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

猜你还喜欢下面的内容

搜索引擎优化知识

分类信息网站

LOGO设计　　 　盐亭网站制作公司　　 　成都租用服务器　　 　成都全屋定制　　 　眉山服务器租用　　 　大橙子建站　　 　犀浦雨棚定制　　 　软文营销　　 　服务器租凭　　 　营销型网站建设　　 　成都网站建设　　 　网络整合营销　　 　信衡房屋鉴定　　 　抖音代运营　　 　成都富士康招工　　 　Android开发　　 　400电话申请　　 　成都温江机房　　 　双流网站建设　　 　租用服务器