小言_互联网的博客

【C#】async和await

348人阅读  评论(0)

大概理解

查了一个小时的资料:async和await

发现这个大神的解释一针见血,深得我心!以最简单的例子,解释了async和await。妙~~~

大多情况下,分开才能体现async和await的价值!

 但,await 并没有这么简单。

深入分析

await和Wait()的区别

接下来继续往下看:

await Task.Delay(3000);  和Task.Delay(3000).Wait();   有没有区别?

上代码:


  
  1. using System.Diagnostics;
  2. namespace await_async2
  3. {
  4. internal class Program
  5. {
  6. static public void TestWait()
  7. {
  8. var t = Task.Factory.StartNew(() =>
  9. {
  10. Console.WriteLine( "Start");
  11. Task.Delay( 3000).Wait();
  12. Console.WriteLine( "Done");
  13. });
  14. t.Wait();
  15. Console.WriteLine( "All done");
  16. }
  17. static public void TestWait2()
  18. {
  19. var t = Task.Factory.StartNew( async () =>
  20. {
  21. Console.WriteLine( "Start");
  22. await Task.Delay( 3000);
  23. Console.WriteLine( "Done");
  24. });
  25. t.Wait();
  26. Console.WriteLine( "All done");
  27. }
  28. static public void TestWait3()
  29. {
  30. var t = Task.Run( async () =>
  31. {
  32. Console.WriteLine( "Start");
  33. await Task.Delay( 3000);
  34. Console.WriteLine( "Done");
  35. });
  36. t.Wait();
  37. Console.WriteLine( "All done");
  38. }
  39. static void Main(string[] args)
  40. {
  41. TestWait2();
  42. //避免程序提前退出,导致一些现象看不到
  43. Task.Delay( 5000).Wait();
  44. }
  45. }
  46. }

首先,强调一下,最后一句 Task.Delay(5000).Wait(); 是必须的,不然,程序提前退出,导致一些现象看不到,从而蒙蔽了我们。

第1段代码TestWait执行效果,如下:

第2段代码TestWait2执行效果,如下:

第3段代码TestWait3执行效果,如下:

 现在给出结论:

Task.Delay(3000).Wait(); 这个就是同步等。

await Task.Delay(3000); 因为没有分开来写(见第一张图),所以基本和同步等没有区别。

但是如果 await Task.Delay(3000); 是写到:Task.Factory.StartNew里面的


  
  1. static public void TestWait2()
  2. {
  3. var t = Task.Factory.StartNew( async () =>
  4. {
  5. Console.WriteLine( "Start");
  6. await Task.Delay( 3000);
  7. Console.WriteLine( "Done");
  8. });
  9. t.Wait();
  10. Console.WriteLine( "All done");
  11. }

那这个效果不一样了,他们执行的权限丢出去了有点像python里的yeild,来看下程序的执行顺序:

 这里就看出了:await Task.Delay(3000);  和Task.Delay(3000).Wait(); 的区别了。(但是这种情况如果在道Task.Run里面就体现不出来!)

然后,我有简单做了一个实验:

这就更明了了, await Task.Delay(3000); 就像设置了一个回调,一旦三秒时间一到,程序的指针就会回到await Task.Delay(3000);后面的位置,直到函数执行结束。再回到之前的位置。这就是所谓的用同步的方式写异步的代码吧

但是,为啥在Task.Factory.StartNew才会体现出来,这个我就不清楚了,请各位大佬指点一下。

去掉Task.Run的Wait

再来对比一下,下面这两个函数:


  
  1. static public void TestWait8()
  2. {
  3. var t = Task.Run( async () =>
  4. {
  5. Console.WriteLine( "Start");
  6. await Task.Delay( 3000);
  7. Console.WriteLine( "Done");
  8. });
  9. Console.WriteLine( "All done");
  10. }
  11. static public void TestWait8_5()
  12. {
  13. var t = Task.Factory.StartNew( async () =>
  14. {
  15. Console.WriteLine( "Start");
  16. await Task.Delay( 3000);
  17. Console.WriteLine( "Done");
  18. });
  19. t.Wait();
  20. Console.WriteLine( "All done");
  21. }

先看第一个TestWait8,由于Task.Run不再调用 t.Wait(),Task.Run内部这个线程主线程是并行的关系。程序指针会在两个线程中来回切换。如果一方中写了await xxx,那程序指针必然跳到另一个线程。直达await结束才可能返回。 这种情形是比较多的。此时await能节省大量等待时间(比如IO操作时间),充分利用等待时间。

此时 Console.WriteLine("All done");会最先被打印出来。

再看第二个TestWait8_5(其实就是回顾一下),当程序执行到t.Wait()时,程序不会继续向下了,(此时因为有t.Wait()的存在,所以子线程其实是优先于主线程的)而是进入到子线程的内部进程,试图将这个线程执行完,但是再线程里面遇到又遇到await Task.Delay(3000);此时程序指针不会再这里死等,程序指针又跳回主线程继续执行,直到三秒到了之后就会回到子线程,子线程执行完了之后,再回到主线程。

但是如果吧TestWait8_5 中    Task.Factory.StartNew 换成 Task.Run ,那么前面的过程一样,只是执行到await Task.Delay(3000);时候,此时会死等,不会跳到主线程,而是一定等到这个子线程完结,再回主线程。

小结

总结一下就是,遇到await 一定会等,至于程序指针是先跳到其他线程,还是在此线程死等,就看你的线程函数这么写的了。

其他

.Await();

最后,还有个:Task.Delay(3000).Await();

这个是prsim对Task写的的一个拓展方法(避免在主线程调用时,阻塞UI):


转载:https://blog.csdn.net/songhuangong123/article/details/127627231
查看评论
* 以上用户言论只代表其个人观点,不代表本网站的观点或立场