learun开发社区 - 力软快速开发平台官方论坛

 找回密码
 立即注册
搜索
热搜: 活动 交友 discuz
查看: 1490|回复: 2

C#异步的世界(上)

[复制链接]

6

主题

6

帖子

22

积分

新手上路

Rank: 1

积分
22
发表于 2019-3-1 13:03:34 | 显示全部楼层 |阅读模式
阅读目录


  • APM
  • EAP
  • TAP
  • 延伸思考




新进阶的程序员可能对async、await用得比较多,却对之前的异步了解甚少。本人就是此类,因此打算回顾学习下异步的进化史。
本文主要是回顾async异步模式之前的异步,下篇文章再来重点分析async异步模式。
APM
APM 异步编程模型,Asynchronous Programming Model
早在C#1的时候就有了APM。虽然不是很熟悉,但是多少还是见过的。就是那些类是BeginXXX和EndXXX的方法,且BeginXXX返回值是IAsyncResult接口。
在正式写APM示例之前我们先给出一段同步代码:
  1. //1、同步方法
  2. private void button1_Click(object sender, EventArgs e)
  3. {         
  4.     Debug.WriteLine("【Debug】线程ID:" + Thread.CurrentThread.ManagedThreadId);

  5.     var request = WebRequest.Create("https://github.com/");//为了更好的演示效果,我们使用网速比较慢的外网
  6.     request.GetResponse();//发送请求   

  7.     Debug.WriteLine("【Debug】线程ID:" + Thread.CurrentThread.ManagedThreadId);
  8.     label1.Text = "执行完毕!";
  9. }
复制代码



【说明】为了更好的演示异步效果,这里我们使用winform程序来做示例。(因为winform始终都需要UI线程渲染界面,如果被UI线程占用则会出现“假死”状态)
【效果图】
看图得知:
  • 我们在执行方法的时候页面出现了“假死”,拖不动了。
  • 我们看到打印结果,方法调用前和调用后线程ID都是9(也就是同一个线程)
下面我们再来演示对应的异步方法:(BeginGetResponse、EndGetResponse所谓的APM异步模型)
  1. private void button2_Click(object sender, EventArgs e)
  2. {
  3.     //1、APM 异步编程模型,Asynchronous Programming Model
  4.     //C#1[基于IAsyncResult接口实现BeginXXX和EndXXX的方法]            
  5.     Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);

  6.     var request = WebRequest.Create("https://github.com/");
  7.     request.BeginGetResponse(new AsyncCallback(t =>//执行完成后的回调
  8.     {
  9.         var response = request.EndGetResponse(t);
  10.         var stream = response.GetResponseStream();//获取返回数据流

  11.         using (StreamReader reader = new StreamReader(stream))
  12.         {
  13.             StringBuilder sb = new StringBuilder();
  14.             while (!reader.EndOfStream)
  15.             {
  16.                 var content = reader.ReadLine();
  17.                 sb.Append(content);
  18.             }
  19.             Debug.WriteLine("【Debug】" + sb.ToString().Trim().Substring(0, 100) + "...");//只取返回内容的前100个字符
  20.             Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
  21.             label1.Invoke((Action)(() => { label1.Text = "执行完毕!"; }));//这里跨线程访问UI需要做处理
  22.         }
  23.     }), null);

  24.     Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
  25. }
复制代码



【效果图】
看图得知:
  • 启用异步方法并没有是UI界面卡死
  • 异步方法启动了另外一个ID为12的线程
上面代码执行顺序:
前面我们说过,APM的BebinXXX必须返回IAsyncResult接口。那么接下来我们分析IAsyncResult接口:
首先我们看:
确实返回的是IAsyncResult接口。那IAsyncResult到底长的什么样子?:
并没有想象中的那么复杂嘛。我们是否可以尝试这实现这个接口,然后显示自己的异步方法呢?
首先定一个类MyWebRequest,然后继承IAsyncResult:(下面是基本的伪代码实现)
  1. public class MyWebRequest : IAsyncResult
  2. {
  3.     public object AsyncState
  4.     {
  5.         get { throw new NotImplementedException(); }
  6.     }

  7.     public WaitHandle AsyncWaitHandle
  8.     {
  9.         get { throw new NotImplementedException(); }
  10.     }

  11.     public bool CompletedSynchronously
  12.     {
  13.         get { throw new NotImplementedException(); }
  14.     }

  15.     public bool IsCompleted
  16.     {
  17.         get { throw new NotImplementedException(); }
  18.     }
  19. }
复制代码



这样肯定是不能用的,起码也得有个存回调函数的属性吧,下面我们稍微改造下:
然后我们可以自定义APM异步模型了:(成对的Begin、End)
  1. public IAsyncResult MyBeginXX(AsyncCallback callback)
  2. {
  3.     var asyncResult = new MyWebRequest(callback, null);
  4.     var request = WebRequest.Create("https://github.com/");
  5.     new Thread(() =>  //重新启用一个线程
  6.     {
  7.         using (StreamReader sr = new StreamReader(request.GetResponse().GetResponseStream()))
  8.         {
  9.             var str = sr.ReadToEnd();
  10.             asyncResult.SetComplete(str);//设置异步结果
  11.         }

  12.     }).Start();
  13.     return asyncResult;//返回一个IAsyncResult
  14. }

  15. public string MyEndXX(IAsyncResult asyncResult)
  16. {
  17.     MyWebRequest result = asyncResult as MyWebRequest;
  18.     return result.Result;
  19. }
复制代码



调用如下:
  1. private void button4_Click(object sender, EventArgs e)
  2. {
  3.      Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
  4.      MyBeginXX(new AsyncCallback(t =>
  5.      {
  6.          var result = MyEndXX(t);
  7.          Debug.WriteLine("【Debug】" + result.Trim().Substring(0, 100) + "...");
  8.          Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
  9.      }));
  10.      Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
  11. }
复制代码



效果图:
我们看到自己实现的效果基本上和系统提供的差不多。
  • 启用异步方法并没有是UI界面卡死
  • 异步方法启动了另外一个ID为11的线程
【总结】
个人觉得APM异步模式就是启用另外一个线程执行耗时任务,然后通过回调函数执行后续操作。
APM还可以通过其他方式获取值,如:
  1. while (!asyncResult.IsCompleted)//循环,直到异步执行完成 (轮询方式)
  2. {
  3.     Thread.Sleep(100);
  4. }
  5. var stream2 = request.EndGetResponse(asyncResult).GetResponseStream();
复制代码


  1. asyncResult.AsyncWaitHandle.WaitOne();//阻止线程,直到异步完成 (阻塞等待)
  2. var stream2 = request.EndGetResponse(asyncResult).GetResponseStream();
复制代码



补充:如果是普通方法,我们也可以通过委托异步:(BeginInvoke、EndInvoke)
  1. public void MyAction()
  2. {
  3.      var func = new Func<string, string>(t =>
  4.      {
  5.          Thread.Sleep(2000);
  6.          return "name:" + t + DateTime.Now.ToString();
  7.      });

  8.      var asyncResult = func.BeginInvoke("张三", t =>
  9.      {
  10.          string str = func.EndInvoke(t);
  11.          Debug.WriteLine(str);
  12.      }, null);
  13. }
复制代码



EAP
EAP 基于事件的异步模式,Event-based Asynchronous Pattern
此模式在C#2的时候随之而来。
先来看个EAP的例子:
  1. private void button3_Click(object sender, EventArgs e)
  2. {            
  3.      Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);

  4.      BackgroundWorker worker = new BackgroundWorker();
  5.      worker.DoWork += new DoWorkEventHandler((s1, s2) =>
  6.      {
  7.          Thread.Sleep(2000);
  8.          Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
  9.      });//注册事件来实现异步
  10.      worker.RunWorkerAsync(this);
  11.      Debug.WriteLine("【Debug】主线程ID:" + Thread.CurrentThread.ManagedThreadId);
  12. }
复制代码




【效果图】(同样不会阻塞UI界面)
【特征】
  • 通过事件的方式注册回调函数
  • 通过 XXXAsync方法来执行异步调用
例子很简单,但是和APM模式相比,是不是没有那么清晰透明。为什么可以这样实现?事件的注册是在干嘛?为什么执行RunWorkerAsync会触发注册的函数?
感觉自己又想多了...
我们试着反编译看看源码:
只想说,这么玩,有意思吗?
TAP
TAP 基于任务的异步模式,Task-based Asynchronous Pattern
到目前为止,我们觉得上面的APM、EAP异步模式好用吗?好像没有发现什么问题。再仔细想想...如果我们有多个异步方法需要按先后顺序执行,并且需要(在主进程)得到所有返回值。
首先定义三个委托:
  1. public Func<string, string> func1()
  2. {
  3.     return new Func<string, string>(t =>
  4.     {
  5.         Thread.Sleep(2000);
  6.         return "name:" + t;
  7.     });
  8. }
  9. public Func<string, string> func2()
  10. {
  11.     return new Func<string, string>(t =>
  12.     {
  13.         Thread.Sleep(2000);
  14.         return "age:" + t;
  15.     });
  16. }
  17. public Func<string, string> func3()
  18. {
  19.     return new Func<string, string>(t =>
  20.     {
  21.         Thread.Sleep(2000);
  22.         return "sex:" + t;
  23.     });
  24. }
复制代码



然后按照一定顺序执行:
  1. public void MyAction()
  2. {
  3.     string str1 = string.Empty, str2 = string.Empty, str3 = string.Empty;
  4.     IAsyncResult asyncResult1 = null, asyncResult2 = null, asyncResult3 = null;
  5.     asyncResult1 = func1().BeginInvoke("张三", t =>
  6.     {
  7.         str1 = func1().EndInvoke(t);
  8.         Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
  9.         asyncResult2 = func2().BeginInvoke("26", a =>
  10.         {
  11.             str2 = func2().EndInvoke(a);
  12.             Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
  13.             asyncResult3 = func3().BeginInvoke("男", s =>
  14.             {
  15.                 str3 = func3().EndInvoke(s);
  16.                 Debug.WriteLine("【Debug】异步线程ID:" + Thread.CurrentThread.ManagedThreadId);
  17.             }, null);
  18.         }, null);
  19.     }, null);

  20.     asyncResult1.AsyncWaitHandle.WaitOne();
  21.     asyncResult2.AsyncWaitHandle.WaitOne();
  22.     asyncResult3.AsyncWaitHandle.WaitOne();
  23.     Debug.WriteLine(str1 + str2 + str3);
  24. }
复制代码



除了难看、难读一点好像也没什么 。不过真的是这样吗?
asyncResult2是null?
由此可见在完成第一个异步操作之前没有对asyncResult2进行赋值,asyncResult2执行异步等待的时候报异常。那么如此我们就无法控制三个异步函数,按照一定顺序执行完成后再拿到返回值。(理论上还是有其他办法的,只是会然代码更加复杂)

是的,现在该我们的TAP登场了。
只需要调用Task类的静态方法Run,即可轻轻松松使用异步。
获取返回值:
  1. var task1 = Task<string>.Run(() =>
  2. {
  3.     Thread.Sleep(1500);
  4.     Console.WriteLine("【Debug】task1 线程ID:" + Thread.CurrentThread.ManagedThreadId);
  5.     return "张三";
  6. });
  7. //其他逻辑            
  8. task1.Wait();
  9. var value = task1.Result;//获取返回值
  10. Console.WriteLine("【Debug】主 线程ID:" + Thread.CurrentThread.ManagedThreadId);
复制代码



现在我们处理上面多个异步按序执行:
  1. Console.WriteLine("【Debug】主 线程ID:" + Thread.CurrentThread.ManagedThreadId);
  2. string str1 = string.Empty, str2 = string.Empty, str3 = string.Empty;
  3. var task1 = Task.Run(() =>
  4. {
  5.     Thread.Sleep(500);
  6.     str1 = "姓名:张三,";
  7.     Console.WriteLine("【Debug】task1 线程ID:" + Thread.CurrentThread.ManagedThreadId);
  8. }).ContinueWith(t =>
  9. {
  10.     Thread.Sleep(500);
  11.     str2 = "年龄:25,";
  12.     Console.WriteLine("【Debug】task2 线程ID:" + Thread.CurrentThread.ManagedThreadId);
  13. }).ContinueWith(t =>
  14. {
  15.     Thread.Sleep(500);
  16.     str3 = "爱好:妹子";
  17.     Console.WriteLine("【Debug】task3 线程ID:" + Thread.CurrentThread.ManagedThreadId);
  18. });

  19. Thread.Sleep(2500);//其他逻辑代码

  20. task1.Wait();

  21. Debug.WriteLine(str1 + str2 + str3);
  22. Console.WriteLine("【Debug】主 线程ID:" + Thread.CurrentThread.ManagedThreadId);
复制代码



[效果图]
我们看到,结果都得到了,且是异步按序执行的。且代码的逻辑思路非常清晰。如果你感受还不是很大,那么你现象如果是100个异步方法需要异步按序执行呢?用APM的异步回调,那至少也得异步回调嵌套100次。那代码的复杂度可想而知。
延伸思考
  • WaitOne完成等待的原理
  • 异步为什么会提升性能
  • 线程的使用数量和CPU的使用率有必然的联系吗


问题1:WaitOne完成等待的原理
在此之前,我们先来简单的了解下多线程信号控制AutoResetEvent类。
  1. var _asyncWaitHandle = new AutoResetEvent(false);
  2. _asyncWaitHandle.WaitOne();
复制代码


此代码会在 WaitOne 的地方会一直等待下去。除非有另外一个线程执行 AutoResetEvent 的set方法。
  1. var _asyncWaitHandle = new AutoResetEvent(false);
  2. _asyncWaitHandle.Set();
  3. _asyncWaitHandle.WaitOne();
复制代码


如此,到了 WaitOne 就可以直接执行下去。没有有任何等待。
现在我们对APM 异步编程模型中的 WaitOne 等待是不是知道了点什么呢。我们回头来实现之前自定义异步方法的异步等待。
  1. public class MyWebRequest : IAsyncResult
  2. {
  3.     //异步回调函数(委托)
  4.     private AsyncCallback _asyncCallback;
  5.     private AutoResetEvent _asyncWaitHandle;
  6.     public MyWebRequest(AsyncCallback asyncCallback, object state)
  7.     {
  8.         _asyncCallback = asyncCallback;
  9.         _asyncWaitHandle = new AutoResetEvent(false);
  10.     }
  11.     //设置结果
  12.     public void SetComplete(string result)
  13.     {
  14.         Result = result;
  15.         IsCompleted = true;
  16.         _asyncWaitHandle.Set();
  17.         if (_asyncCallback != null)
  18.         {
  19.             _asyncCallback(this);
  20.         }
  21.     }
  22.     //异步请求返回值
  23.     public string Result { get; set; }
  24.     //获取用户定义的对象,它限定或包含关于异步操作的信息。
  25.     public object AsyncState
  26.     {
  27.         get { throw new NotImplementedException(); }
  28.     }
  29.     // 获取用于等待异步操作完成的 System.Threading.WaitHandle。
  30.     public WaitHandle AsyncWaitHandle
  31.     {
  32.         //get { throw new NotImplementedException(); }

  33.         get { return _asyncWaitHandle; }
  34.     }
  35.     //获取一个值,该值指示异步操作是否同步完成。
  36.     public bool CompletedSynchronously
  37.     {
  38.         get { throw new NotImplementedException(); }
  39.     }
  40.     //获取一个值,该值指示异步操作是否已完成。
  41.     public bool IsCompleted
  42.     {
  43.         get;
  44.         private set;
  45.     }
  46. }
复制代码



红色代码就是新增的异步等待。
【执行步骤】

问题2:异步为什么会提升性能
比如同步代码:
  1. Thread.Sleep(10000);//假设这是个访问数据库的方法
  2. Thread.Sleep(10000);//假设这是个访问翻墙网站的方法
复制代码


这个代码需要20秒。
如果是异步:
  1. var task = Task.Run(() =>
  2. {
  3.     Thread.Sleep(10000);//假设这是个访问数据库的方法
  4. });
  5. Thread.Sleep(10000);//假设这是个访问翻墙网站的方法
  6. task.Wait();
复制代码



如此就只要10秒了。这样就节约了10秒。
如果是:
  1. var task = Task.Run(() =>
  2. {
  3.     Thread.Sleep(10000);//假设这是个访问数据库的方法
  4. });
  5. task.Wait();
复制代码


异步执行中间没有耗时的代码那么这样的异步将是没有意思的。
或者:
  1. var task = Task.Run(() =>
  2. {
  3.     Thread.Sleep(10000);//假设这是个访问数据库的方法
  4. });
  5. task.Wait();
  6. Thread.Sleep(10000);//假设这是个访问翻墙网站的方法
复制代码



把耗时任务放在异步等待后,那这样的代码也是不会有性能提升的。
还有一种情况:
如果是单核CPU进行高密集运算操作,那么异步也是没有意义的。(因为运算是非常耗CPU,而网络请求等待不耗CPU)

问题3:线程的使用数量和CPU的使用率有必然的联系吗
答案是否。
还是拿单核做假设。
情况1:
  1. long num = 0;
  2. while (true)
  3. {
  4.     num += new Random().Next(-100,100);
  5.     //Thread.Sleep(100);
  6. }
复制代码



单核下,我们只启动一个线程,就可以让你CPU爆满。
启动八次,八进程CPU基本爆满。
情况2:
一千多个线程,而CPU的使用率竟然是0。由此,我们得到了之前的结论,线程的使用数量和CPU的使用率没有必然的联系。
虽然如此,但是也不能毫无节制的开启线程。因为:
  • 开启一个新的线程的过程是比较耗资源的。(可是使用线程池,来降低开启新线程所消耗的资源)
  • 多线程的切换也是需要时间的。
  • 每个线程占用了一定的内存保存线程上下文信息。


回复

使用道具 举报

0

主题

7

帖子

147

积分

注册会员

Rank: 2

积分
147
发表于 2019-3-1 13:56:11 | 显示全部楼层
厉害
回复

使用道具 举报

0

主题

2

帖子

73

积分

注册会员

Rank: 2

积分
73
发表于 2019-3-8 02:19:29 | 显示全部楼层
大神,多写一些
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

Archiver|手机版|小黑屋|learun开发社区 - 力软快速开发平台官方论坛 ( 沪ICP备14034717号 )

GMT+8, 2020-4-8 03:14 , Processed in 0.197670 second(s), 24 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表