转载

C＃：异步编程和线程的使用（.NET 4.5 ）

C＃：异步编程和线程的使用（.NET 4.5 ）

异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。

本文中涉及关键知识点

1. 异步编程

2. 线程的使用

3. 基于任务的异步模式

4. 并行编程

5. 总结

  • 异步编程

什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序从Main方法开始，当Main方法返回时结束。所有的操作都是按顺序执行的。执行操作是有序列的，一个操作必须等到其前面的操作完成才能够执行。如以下代码示例：

   1:  static void Main(string[] args)
   2:   
   3:  {
   4:   
   5:  DoTaskOne();
   6:   
   7:  DoTaskTwo();
   8:   
   9:  }

“DoTaskOne”方法结束后，DoTaskTwo()才能够执行。

异步编程中常用后台运行的方法体现，主调用线程不会被阻塞。调用后台运行的方法后，执行流程会立即返回到调用的线程并继续执行其他任务。后台运行方法通常是用线程或任务来实现。

在上面的例子中，在“DoTaskOne”方法调用成功后，如果“DoTaskOne”是异步调用，，执行流程立即返回到Main方法中，并继续执行“DoTaskTwo” 方法。

C#提供了Thread类创建线程实现异步编程，或者使用.NET提供的异步模式实现异步编程。.NET中提供了三种不同的异步模式：

1. 异步编程模型（APM）模式

2. 基于事件的异步模式（EAP）

3. 基于任务的异步模式（TAP）

前两种模型微软官方并不推荐使用，本文不再详细描述。我们将详细讨论基于任务的异步模式（TAP）：

  • 线程的使用

在.NET 4.5中引入了异步编程模式，大部分情况下都不需要我们手动创建线程。编译器已经替代了开发人员来完成这项工作。

创建新线程是非常耗时的。一般情况下，异步和并行编程使用 “基于任务的异步模式（TAP）”和“任务并行库（TPL）”就够了。如果需要控制线程的功能则需要使用其他模式。

TAP和TPL都是基于任务。一般来说任务是从线程池中调用线程（ 线程池 是 .NET框架创建的和维护的线程集。如果我们使用任务，就不需要直接调用线程池。

任务可以在以下情况运行：

1. 在正在运行的线程中

2. 在新线程中

3. 从线程池中的某一线程中

4. 没有线程也可以运行

如果使用任务机制，开发人员就不必担心线程的创建或使用，.NET框架已经为我们解决了这一难题。

有时候需要控制线程，执行以下操作：

1. 设置线程名称

2. 设置线程优先级

3. 设置线程是前端或后端运行

我们可以使用线程类来创建线程。

使用Thread类创建线程

Thread类的构造函数接收委托类型的参数

1. ThreadStart：定义了返回值为空的方法，且不带参数的方法。

2. ParameterizedThreadStart：定义了返回值为空且有一个object类型的参数。

下面是一个简单的例子，使用 Start方法启动一个新线程：

   1:  static void Main(string[] args)
   2:   
   3:  {
   4:   
   5:  Thread thread = new Thread(DoTask);
   6:   
   7:  thread.Start();// Start DoTask method in a new thread
   8:   
   9:  //Do other tasks in main thread
  10:   
  11:  }
  12:   
  13:  static public void DoTask() {
  14:   
  15:  //do something in a new thread 
  16:   
  17:  }

可以用Lamda表达式代替线程名称：

   1:  static void Main(string[] args)
   2:   
   3:  {
   4:   
   5:  Thread thread = new Thread(() => {
   6:   
   7:  //do something in a new thread
   8:   
   9:  });
  10:   
  11:  thread.Start();// Start a new thread
  12:   
  13:  //Do other tasks in main thread
  14:   
  15:  }

如果不需要引用变量，可如下直接启动线程：

   1:  static void Main(string[] args)
   2:   
   3:  {
   4:   
   5:  new Thread(() => {
   6:   
   7:  //do something in a new thread
   8:   
   9:  }).Start();// Start a new thread
  10:   
  11:  //Do other tasks in main thread
  12:   
  13:  }

但是，如果想控制线程对象，对线程设置一些属性，需要在线程创建后引用线程变量。如下可给线程对象的不同属性设值：

   1:  static void Main(string[] args)
   2:   
   3:  {
   4:   
   5:  Thread thread = new Thread(DoTask);
   6:   
   7:  thread.Name = "My new thread";// Asigning name to the thread
   8:   
   9:  thread.IsBackground = false;// Made the thread forground
  10:   
  11:  thread.Priority = ThreadPriority.AboveNormal;// Setting thread priority
  12:   
  13:  thread.Start();// Start DoTask method in a new thread
  14:   
  15:  //Do other task in main thread
  16:   
  17:  }

调用引用变量，可以执行一些操作如中止线程或通过调用join方法等待阻塞线程。

如果需要通过函数传值，可以给Start方法传值。由于该方法的参数为Object类型，因此需要强制转换类型。

   1:  static void Main(string[] args)
   2:   
   3:  {
   4:   
   5:  Thread thread = new Thread(DoTaskWithParm);
   6:   
   7:  thread.Start("Passing string");// Start DoTaskWithParm method in a new thread
   8:   
   9:  //Do other task in main thread
  10:   
  11:  }
  12:   
  13:  static public void DoTaskWithParm(object data)
  14:   
  15:  {
  16:   
  17:  //we need to cast the data to appropriate object
  18:   
  19:  }

“async”和“await”关键字

.NET框架引入了两个新的关键字来实现异步编程：“async”和“await”。使用 “await”的异步方法必须由“async”修饰符来声明方法。“await”关键字修饰调用异步方法。await 运算符应用于一个异步方法中的任务以挂起该方法的执行，直到等待任务完成.如下：

   1:  private async static void CallerWithAsync()// async modifier is used 
   2:   
   3:  {
   4:   
   5:  string result = await GetSomethingAsync();// await is used before a method call. It suspends
   6:     //execution of CallerWithAsync() method and control returs to the calling thread that can 
          //perform other task. 
   7:   
   8:  Console.WriteLine(result);
   9:     // this line would not be executed before GetSomethingAsync() //method completes 
  10:   
  11:  }

而“ async ”修饰符只能用于返回值为Task类型或Void的方法。它不能用于主程序的切入点。

所有的方法之前不能使用await关键字，使用“await”关键字方法必须返回 “可等待”类型。以下属于“可等待”类型：

1. Task

2. Task<T>

3. 自定义“可等待”类型。

  • 基于任务的异步模式

首先我们需要声明一个返回类型为Task或Task<T>的异步方法。可以通过以下几种方式创建任务：

1. Task.Factory.StartNew方法：在之前的.NET版本（在.NET 4中），是创建和启动任务的主要方法。

2. Task.Run或Task.Run <T>方法：从.NET 4.5这个方法已经被使用。此方法足以满足常见情况。

3. Task.FromResult方法：如果结果是已计算，就可以用这个方法来创建任务。

创建并等待一个任务

使用Task.Run <T>方法创建Task。该方法将特定工作按顺序排列在线程池中运行，并返回工作的任务句柄。需要以下步骤从同步方法中创建异步任务：

1. 假设下面方法是同步的，但需要一定的时间来完成：

   1:  static string Greeting(string name)
   2:   
   3:  {
   4:   
   5:  Thread.Sleep(3000);
   6:   
   7:  return string.Format("Hello, {0}", name);
   8:   
   9:  }

2. 要以异步方式访问此方法，必须以异步方式封装。命名为“GreetingAsync”。增加“Async”的后缀命名异步方法。

   1:  static Task<string> GreetingAsync(string name)
   2:   
   3:  {
   4:   
   5:  return Task.Run<string>(() =>
   6:   
   7:  {
   8:   
   9:  return Greeting(name);
  10:   
  11:  });
  12:   
  13:  }

3.现在，可通过使用的await关键字调用异步方法GreetingAsync

   1:  private async static void CallWithAsync()
   2:   
   3:  {
   4:   
   5:  //some other tasks 
   6:   
   7:  string result = await GreetingAsync("Bulbul");
   8:   
   9:  //We can add multiple “await” in same “async” method 
  10:   
  11:  //string result1 = await GreetingAsync(“Ahmed”); 
  12:   
  13:  //string result2 = await GreetingAsync(“Every Body”); 
  14:   
  15:  Console.WriteLine(result);
  16:   
  17:  }

当“CallWithAsync”方法被调用时，与常规的同步方法一样执行，直到遇到“await”的关键字。当它执行到 await的关键字会处理执行，并开始等待“GreetingAsync（” Bulbul “）” 方法被完成。同时，程序流将返回” CallWithAsync “方法的调用者，并继续执行调用者的任务。

当“GreetingAsync（" Bulbul "） 方法完成，“CallWithAsync”的方法恢复 “await关键字后的其他任务。在本实例中，将继续执行的代码“Console.WriteLine（result）”

4. 使用任务持续：Task类 “ContinueWith”的方法定义了Task完成后被调用的代码。

   1:  private static void CallWithContinuationTask()
   2:   
   3:  {
   4:   
   5:  Task<string> t1 = GreetingAsync("Bulbul");
   6:   
   7:  t1.ContinueWith(t =>
   8:   
   9:  {
  10:   
  11:  string result = t.Result;
  12:   
  13:  Console.WriteLine(result);
  14:   
  15:  });
  16:   
  17:  }

如果使用“ContinueWith”的方法就不需要使用“await“关键字，编译器会自动在合适的位置中添加“await”关键字。

等候多 个异步方法。

看看下面的代码：

   1:  private async static void CallWithAsync()
   2:   
   3:  {
   4:   
   5:  string result = await GreetingAsync("Bulbul");
   6:   
   7:  string result1 = await GreetingAsync(“Ahmed”);
   8:   
   9:  Console.WriteLine(result);
  10:   
  11:  Console.WriteLine(result1);
  12:   
  13:  }

有两个正在等待调用函数序列。“GreetingAsync（” Ahmed “）” 会在完成第一个呼叫“GreetingAsync（” Bulbul “）” 之后启动。如果“result”和上面的代码“result1”是独立的，那么连续的“awiating”并不是一个好的做法。

在这种情况下，我们可以简化调用方法，不需要添加多个“await”关键字，只在一个地方添加await关键字，如下所示，这种情况下，该方法的调用都可以并行执行。

   1:  private async static void MultipleAsyncMethodsWithCombinators()
   2:   
   3:  {
   4:   
   5:  Task<string> t1 = GreetingAsync("Bulbul");
   6:   
   7:  Task<string> t2 = GreetingAsync("Ahmed");
   8:   
   9:  await Task.WhenAll(t1, t2);
  10:   
  11:  Console.WriteLine("Finished both methods./n " +
  12:   
  13:  "Result 1: {0}/n Result 2: {1}", t1.Result, t2.Result);
  14:   
  15:  }

在这里，我们使用Task.WhenAll连接器。Task.WhenAll创建一个任务，将完成所有的提供的任务。Task类也有其他的结合器。Task.WhenAny，当所任务链中所有的任务完成时，结束使用。

处理异常

必须把“await的代码块放在try块内捕获异常。

   1:  private async static void CallWithAsync()
   2:   
   3:  {
   4:   
   5:  try
   6:   
   7:  {
   8:   
   9:  string result = await GreetingAsync("Bulbul");
  10:   
  11:  }
  12:   
  13:  catch (Exception ex)
  14:   
  15:  {
  16:   
  17:  Console.WriteLine(“handled {0}”, ex.Message);
  18:   
  19:  }
  20:   
  21:  }

如果try块中有多个“ await ”，只有第一个” await “异常会被处理，其他“ await ”将无法被捕捉。如果希望所有的方法都能捕获异常，不能使用“await”关键字调用方法，使用Task.WhenAll来执行任务。 

   1:  private async static void CallWithAsync()
   2:   
   3:  {
   4:   
   5:  try
   6:   
   7:  {
   8:   
   9:  Task<string> t1 = GreetingAsync("Bulbul");
  10:   
  11:  Task<string> t2 = GreetingAsync("Ahmed");
  12:   
  13:  await Task.WhenAll(t1, t2);
  14:   
  15:  }
  16:   
  17:  catch (Exception ex)
  18:   
  19:  {
  20:   
  21:  Console.WriteLine(“handled {0}”, ex.Message);
  22:   
  23:  }
  24:   
  25:  }

捕获所有任务的错误一种方法是在try块之外声明任务，这样可以从try块进行访问，并检查任务的“IsFaulted”属性。如果它存在异常那么“IsFaulted”属性值为True，就可捕获任务实例的内部异常。

还有另一个更好的办法：

   1:  static async void ShowAggregatedException()
   2:   
   3:  {
   4:   
   5:  Task taskResult = null;
   6:   
   7:  try
   8:   
   9:  {
  10:  Task<string> t1 = GreetingAsync("Bulbul");
  11:   
  12:  Task<string> t2 = GreetingAsync("Ahmed");
  13:   
  14:  await (taskResult = Task.WhenAll(t1, t2));
  15:   
  16:  }
  17:   
  18:  catch (Exception ex)
  19:   
  20:  {
  21:   
  22:  Console.WriteLine("handled {0}", ex.Message);
  23:   
  24:  foreach (var innerEx in taskResult.Exception.InnerExceptions)
  25:   
  26:  {
  27:  Console.WriteLine("inner exception {0}", nnerEx.Message); }
  28:  }
  29:   
  30:  }

取消任务

在此之前，如果从线程池中调用线程，线程是不可能取消。现在，Task类提供了一个方法基于CancellationTokenSource类能够取消已启动的任务，取消任务步骤：

1. 异步方法应该除外 “ CancellationToken” 参数类型

2. 创建CancellationTokenSource类实例：

var cts =new CancellationTokenSource();

3. 传递CancellationToken，如：

   1:    Task<string> t1 = GreetingAsync("Bulbul", cts.Token);

4. 长时间运行的方法中，必须调用CancellationToken 的 ThrowIfCancellationRequested （）方法 。 

   1:   static string Greeting(string name, CancellationToken token){
   2:   
   3:  Thread.Sleep(3000);
   4:   
   5:  token. ThrowIfCancellationRequested();
   6:   
   7:  return string.Format("Hello, {0}", name);
   8:   
   9:  } 


5. 从等待的Task中捕获 OperationCanceledException异常。

6. 如果通过调用CancellationTokenSource的实例的方法执行取消操作，将从长时间运行操作中抛出OperationCanceledException异常。也可以设置取消的时间。以下是完整的代码，一秒后执行取消操作：

   1:   static void Main(string[] args)
   2:   
   3:   {
   4:   CallWithAsync();
   5:   
   6:  Console.ReadKey();
   7:   
   8:   }
   9:   
  10:   
  11:  async static void CallWithAsync()
  12:   
  13:  {
  14:   
  15:  try
  16:   
  17:   {
  18:   
  19:  CancellationTokenSource source = new CancellationTokenSource();
  20:   
  21:  source.CancelAfter(TimeSpan.FromSeconds(1));
  22:   
  23:   var t1 = await GreetingAsync("Bulbul", source.Token);
  24:   }
  25:   
  26:   catch (OperationCanceledException ex)
  27:   
  28:  {
  29:   
  30:   Console.WriteLine(ex.Message);
  31:   
  32:   }
  33:   
  34:   }
  35:   
  36:  static Task<string> GreetingAsync(string name, CancellationToken token)
  37:   
  38:   {
  39:   
  40:   return Task.Run<string>(() =>
  41:   
  42:   {
  43:   
  44:   return Greeting(name, token);
  45:   
  46:   });
  47:  }
  48:   
  49:   
  50:   static string Greeting(string name, CancellationToken token)
  51:   
  52:   {
  53:   
  54:  Thread.Sleep(3000);
  55:   token.ThrowIfCancellationRequested();
  56:   
  57:   return string.Format("Hello, {0}", name);
  58:   
  59:   }
  60:

  • 并行编程

.NET 4.5及以上版本推出“Parallel类，是线程类的抽象。使用“Parallel”类，我们可以实现并行。并行与线程不同，它使用所有可用的CPU或内核的。以下两种类型的并行是可行：

  1. 数据并行：如果我们有数据的大集合，我们希望在每个数据的某些操作进行并行使用，那么就可以使用数据并行。Parallel类有静态For或ForEach来执行数据并行行，如
   1:  ParallelLoopResult result =
   2:                      Parallel.For(0, 100, async (int i) =>
   3:                      {
   4:                          Console.WriteLine("{0}, task: {1}, thread: {2}", i,
   5:                          Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
   6:                          await Task.Delay(10);
   7:  
   8:                });

For或ForEach方法可以在多线程中和且索引无序可以是无序的。

如果想停止并行For或ForEach方法，可通过ParallelLoopState作为参数，并根据需要打破循环的状态，跳出循环。

   1:  ParallelLoopResult result =
   2:                      Parallel.For(0, 100, async (int i, ParallelLoopState pls) =>
   3:                      {
   4:                          Console.WriteLine("{0}, task: {1}, thread: {2}", i,
   5:                          Task.CurrentId, Thread.CurrentThread.ManagedThreadId);
   6:                          await Task.Delay(10);
   7:                          if (i > 5) pls.Break();
   8:                });

2. 任务并行：如果想要同时运行多个任务的，我们可以通过调用Parallel类的invoke方法使用任务并行Parallel.Invoke方法接收委托行为的数组。例如：

   1:  static void ParallelInvoke()
   2:   
   3:  {
   4:   
   5:  Parallel.Invoke(MethodOne, MethodTwo);
   6:   
   7:  }
   8:
正文到此结束
所属分类： 编程技术

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
Java入门教程 bootstrap3 CSS Apache基础教程 springboot-demo php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 Struts2教程 MongoDB教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 SpringCloud ANTLR教程 Hive教程 java实例教程 Ant教程 Hazelcast教程 Elastic-Job-Lite XStream教程 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 WebService CXF学习 Hadoop教程 solr教程 JPA教程 ActiveMQ中文指南 Java内存模型 dubbo教程 Linux入门视频教程
近期评论
  1. 1 Spring Boot集成zipkin快速入门Demo
  2. 2 能用365块大洋去解决的事，千万不要用时间
  3. 3 Spring Boot集成atomikos快速入门Demo
  4. 4 Spring Boot集成fastdfs快速入门Demo
  5. 5 Spring Boot集成Https快速入门Demo
  6. 6 Spring Boot集成easypoi快速入门Demo
  7. 7 Spring Boot集成webflux快速入门Demo
  8. 8 Spring Boot集成Graphql快速入门Demo
  9. 9 Spring Boot API 多版本快速入门Demo
  10. 10 Spring Boot内容协商快速入门Demo
网站信息
  • 文章总数：155,459 篇
  • 文件总数：468,740 个
  • 标签总数：2,264 个
  • 分类总数：90 个
  • 留言数量：2,540 条
  • 在线人数：676 人
  • 运行天数：4,193天
  • 最后更新：2024年04月20日04点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG