zoukankan      html  css  js  c++  java

  • 4.0中的并行计算和多线程详解(二)

    多线程部分

    多线程在4.0中被简化了很多，仅仅只需要用到System.Threading.Tasks.::.Task类，下面就来详细介绍下Task类的使用。

    一、简单使用

    开启一个线程，执行循环方法，返回结果。开始线程为Start()，等待线程结束为Wait()。

    Code
    1.         /// <summary>
    2.         /// Task简单使用
    3.         /// </summary>
    4.         private void Demo1()
    5.         {
    6.             int i = 0;
    7.             Random r = new Random(DateTime.Now.Second);
    8.             Task t = new Task(() =>
    9.             {
    10.                 for (int v = 0; v < 100; v++)
    11.                     i += r.Next(100);
    12.             });
    14.             t.Start();
    15.             t.Wait();
    17.             Console.WriteLine("这是执行Task1后等待完成：" + i.ToString());
    18.             Console.ReadLine();
    19.         }

    比以前使用Thread方便多了吧。

    上面的例子是使用外部的变量获得结果，下面的例子是用Task<T>直接返回结果，当调用Result属性时，会自动等待线程结束，等同调用了Wait()。代码如下：

    Code
    1.         /// <summary>
    2.         /// Task带返回值
    3.         /// </summary>
    4.         private void Demo2()
    5.         {
    6.             Random r = new Random(DateTime.Now.Second);
    7.             Task<int> t = new Task<int>(() =>
    8.             {
    9.                 int i = 0;
    10.                 for (int v = 0; v < 100; v++)
    11.                     i += r.Next(100);
    12.                 return i;
    13.             });
    15.             t.Start();
    17.             Console.WriteLine("这是执行Task1获取返回值：" + t.Result.ToString());
    18.             Console.ReadLine();
    19.         }

    总结1：Task的使用比Thread简单很多，减少了同步，等待等等问题，唯一的遗憾是不支持Thread的IsBackground。

    结论1：如果不需要使用IsBackground，那么尽情的使用Task吧。

    二、线程执行完毕后调用另一个线程

    也就是两个线程，有序的执行，这里使用ContinueWith()，

    t执行完毕后再执行一个task方法，不多说了代码如下：

    Code
    1.         /// <summary>
    2.         /// Task 执行完毕后调用另一个Task
    3.         /// </summary>
    4.         private void Demo3()
    5.         {
    6.             Random r = new Random(DateTime.Now.Second);
    7.             Task<int> t = new Task<int>(() =>
    8.             {
    9.                 int i = 0;
    10.                 for (int v = 0; v < 100; v++)
    11.                     i += r.Next(100);
    12.                 return i;
    13.             });
    15.             t.ContinueWith((Task<int> task) =>
    16.             {
    17.                 Console.WriteLine("这是执行完毕Task1后继续调用Task2：" + task.Result.ToString());
    18.             });
    20.             t.Start();
    21.             Console.ReadLine();
    22.         }

    也可以直接链式的写下去，代码如下：

    Code
    1.         /// <summary>
    2.         /// Task 执行完毕后调用另一个Task(链式写法)
    3.         /// </summary>
    4.         private void Demo4()
    5.         {
    6.             Random r = new Random(DateTime.Now.Second);
    7.             Task<int> t = new Task<int>(() =>
    8.             {
    9.                 int i = 0;
    10.                 for (int v = 0; v < 100; v++)
    11.                     i += r.Next(100);
    12.                 return i;
    13.             });
    15.             Task t2 = t.ContinueWith((Task<int> task) =>
    16.             {
    17.                 Console.WriteLine(task.Result.ToString());
    18.             });
    20.             t2.ContinueWith(task =>
    21.             {
    22.                 Console.WriteLine("这是执行完毕Task1后继续调用Task2，Task2后调用Task3。");
    23.             });
    25.             t.Start();
    26.             Console.ReadLine();
    27.         }

    结论2：Task可以便捷的将几个方法串行执行。

    三、带有父子关系的线程/多线程并行开启

    t带有t1,t2,t3三个子线程，执行t的时候t1,t2,t3可并行处理，t必须等待t1,t2,t3都执行完毕后才能结束。

    创建子Task时候必须指定参数为AttachedToParent。

    Code
    1.         /// <summary>
    2.         /// 带有父子关系的Task集合，[TaskCreationOptions.AttachedToParent]
    3.         ///
    4.         /// 值                说明
    5.         /// None              默认值，此Task会被排入Local Queue中等待执行，采用LIFO模式。
    6.         /// AttachedToParent  建立的Task必须是外围的Task的子Task，也是放入Local Queue，採LIFO模式。
    7.         /// LongRunning       建立的Task不受Thread Pool所管理，直接新增一个Thread来执行此Task，无等待、无排程。
    8.         /// PreferFairness    建立的Task直接放入Global Queue中，採FIFO模式。(比上面的优先级低)
    9.         /// </summary>
    10.         private void Demo5()
    11.         {
    12.             Task<int> t = new Task<int>(() =>
    13.             {
    14.                 Task<int> t1 = new Task<int>(() =>
    15.                 {
    16.                     int i = 0;
    17.                     Random r = new Random(DateTime.Now.Second);
    18.                     for (int v = 0; v < 100; v++)
    19.                         i += r.Next(100);
    20.                     return i;
    21.                 }, TaskCreationOptions.AttachedToParent);
    23.                 Task<int> t2 = new Task<int>(() =>
    24.                 {
    25.                     int i = 0;
    26.                     Random r = new Random(DateTime.Now.Second);
    27.                     for (int v = 0; v < 100; v++)
    28.                         i += r.Next(100);
    29.                     return i;
    30.                 }, TaskCreationOptions.AttachedToParent);
    32.                 Task<int> t3 = new Task<int>(() =>
    33.                 {
    34.                     int i = 0;
    35.                     Random r = new Random(DateTime.Now.Second);
    36.                     for (int v = 0; v < 100; v++)
    37.                         i += r.Next(100);
    38.                     return i;
    39.                 }, TaskCreationOptions.AttachedToParent);
    40.                 t1.Start();
    41.                 t2.Start();
    42.                 t3.Start();
    43.                 return t1.Result + t2.Result + t3.Result;
    44.             });
    45.             t.Start();
    46.             t.Wait();
    47.             Console.WriteLine("这是带有父子关系的Task集合：" + t.Result.ToString());
    48.             Console.ReadLine();
    49.         }

    结论3：多个线程的同时开启在这里也很方便，也不用担心同步等问题。

    四、Task的中断

    这个很复杂，就不多说了，代码中有比较详细的介绍。

    Code
    1.         /// <summary>
    2.         /// 中途取消Task执行，Token
    3.         ///
    4.         /// 一是正常结束、二是产生例外、三是透过Cancel机制，这三种情况都会反映在Task.Status属性上
    5.         /// 值                              说明
    6.         /// Created                         Task已经建立，但未呼叫Start。
    7.         /// WaitingForActivation            Task已排入排程，但尚未执行(一般我们建立的Task不会有此状态，只有ContinueWith所产生的Task才会有此状态)。
    8.         /// WaitingToRun                    Task已排入排程，等待执行中。
    9.         /// Running                         Task执行中。
    10.         /// WaitingForChildrenToComplete    Task正等待子Task結束。
    11.         /// RanToCompletion                 Task已经正常执行完毕。
    12.         /// Canceled                        Task已被取消。
    13.         /// Faulted                         Task执行中发生未预期例外。
    14.         ///
    15.         /// 除了Status属性外，Task还提供了另外三个属性来判定Task状态。
    16.         /// 属性            说明
    17.         /// IsCompleted     Task已经正常执行完毕。
    18.         /// IsFaulted       Task执行中法生未预期例外。
    19.         /// IsCanceled      Task已被取消。
    20.         /// </summary>
    21.         private void Demo6()
    22.         {
    23.             CancellationTokenSource cts = new CancellationTokenSource();
    25.             var ctoken = cts.Token;
    26.             Task t1 = new Task(() =>
    27.             {
    28.                 for (int v = 0; v < 10; v++)
    29.                 {
    30.                     if (ctoken.IsCancellationRequested)
    31.                     {
    32.                         //第一种写法
    33.                         //这个会抛出异常
    34.                         ctoken.ThrowIfCancellationRequested();
    36.                         //另一种写法
    37.                         //这个不会返回异常，但是获取不到是否是中断还是执行完毕。
    38.                         //return;
    39.                     }
    40.                     Thread.Sleep(1000);
    41.                     Console.WriteLine(v);
    42.                 }
    43.             }, ctoken);
    44.             t1.Start();
    45.             Thread.Sleep(2000);
    46.             cts.Cancel();
    47.             try
    48.             {
    49.                 t1.Wait();
    50.             }
    51.             catch
    52.             {
    53.                 if (t1.IsCanceled)
    54.                     Console.WriteLine("cancel");
    55.             }
    56.             Console.ReadLine();
    57.             cts.Dispose();
    58.         }

    结论4：中断很复杂，但是对一般逻辑来说，是没有很大必要的。

    五、其他

    这里介绍下另一种写法Task.Factory，以及ContinueWhenAny和ContinueWhenAll两个方法。

    Task.Factory是静态工厂类，用于对Task提供一些麻烦的支持，这里主要介绍ContinueWhenAny和ContinueWhenAll。

    ContinueWhenAll所指定的函式会在传入的所有Tasks结束时执行，只会执行一次。

    ContinueWhenAny所指定的函式会在传入的Tasks中有任何一个结束时执行，且与ContinueWhenAll相同，只会执行一次。

    好了，还是看代码：

    Code
    1.         /// <summary>
    2.         /// Task.Factory
    3.         /// ContinueWhenAny和ContinueWhenAll
    4.         /// ContinueWhenAll所指定的函式会在传入的所有Tasks结束时执行，只会执行一次。
    5.         /// ContinueWhenAny所指定的函式会在传入的Tasks中有任何一个结束时执行，且与ContinueWhenAll相同，只会执行一次。
    6.         /// </summary>
    7.         private void Demo7()
    8.         {
    9.             Task<int> t1 = Task.Factory.StartNew<int>(() =>
    10.             {
    11.                 int total = 0;
    12.                 for (int i = 0; i < 10; i++)
    13.                     total += i;
    14.                 Thread.Sleep(12000);
    15.                 return total;
    16.             });
    18.             Task<int> t2 = Task.Factory.StartNew<int>(() =>
    19.             {
    20.                 int total = 0;
    21.                 for (int i = 10; i < 20; i++)
    22.                     total += i;
    23.                 Thread.Sleep(10000);
    24.                 return total;
    25.             });
    27.             Task tfinal = Task.Factory.ContinueWhenAny<int>(
    28.                          new Task<int>[] { t1, t2 }, (Task<int> task) =>
    29.                          {
    30.                              if (task.Status == TaskStatus.RanToCompletion)
    31.                              {
    32.                                  Console.WriteLine(task.Result);
    33.                              }
    34.                          });
    35.             Console.ReadLine();
    36.         }

    结论5：ContinueWhenAny和ContinueWhenAll对特定条件执行，还是有些用处的。

    好了，这篇文章算是完结了，4.0中的并行和线程确实简单了很多，使用起来也很方便，为了性能的提升还是要适当的使用下。

    谢谢观赏
  • 相关阅读:
    iOS软件版本更新思路
    Xcode里-ObjC, -all_load, -force_load
    NSFileManager
    [Android问答] px、dp和sp，这些单位有什么区别？
    annot refer to a non-final variable * inside an inner class defined in a different method"错误解析
    android Handler post sendMessage
    谈layout_gravity和gravity的用法
    Android LayoutInflater详解
    Android中pendingIntent的深入理解
    Intent和PendingIntent的区别
  • 原文地址：https://www.cnblogs.com/sorex/p/1830130.html
Copyright © 2011-2022 走看看