会飞的蚊子 發表於 2023-1-30 17:44:00

通过一个示例形象地理解C# async await异步

<h2 id="前言">前言</h2>
<p>相信大家看过不少讲C# async await的文章，博客园就能搜到很多，但还是有很多C#程序员不明白。<br>
如果搞不明白，其实也不影响使用。但有人就会疑惑，为什么要用异步？我感觉它更慢了，跟同步有啥区别？<br>
有的人研究深入，比如去研究状态机，可能会明白其中的原理。但深入研究的毕竟少数。有的人写一些示例，有的专业有的不是很专业，但看的人仍有不明白的。<br>
所以我写了一个示例，尽量简单，让大家形象地理解一下C#的异步。<br>
就是一个示例，没有什么理论讲解，大家自己测试自己思考。如果大家看理论讲解，就能明白，我也就没必要写这个示例了。</p>
<h2 id="示例的测试步骤">示例的测试步骤</h2>
<p>先直接测试，看结果，下面再放代码</p>
<ol>
<li>点击VS2022的启动按钮，启动程序，它会先启动Server工程，再启动AsyncAwaitDemo2工程</li>
<li>快速连续点击5次button1(调用的是同步方法)</li>
<li>快速连续点击5次button2(调用的是异步方法)</li>
<li>观察思考输出结果，体会异步的好处</li>
</ol>
<h2 id="测试截图">测试截图</h2>
<p><img src="https://img2023.cnblogs.com/blog/174862/202301/174862-20230130170624309-1270862657.jpg"></p>
<h2 id="测试截图说明">测试截图说明</h2>
<ol>
<li>5次点击button1，界面是卡住的，但不影响输出结果，5次点击button2界面不会卡住(截图看不出来，测试过程中有体现)</li>
<li>5次点击button1，共5次同步请求，每个请求耗时2秒，一共耗时10秒，嫌慢，想要并发请求？那你可能要使用Task.Run，在线程中调用同步方法，这又涉及到线程占用问题</li>
<li>5次点击button2，共5次异步请求，每个请求耗时2秒，但一共耗时只有2秒，注意，代码中请求web api接口使用Thread类了吗？没有！使用Task.Run了吗？没有！使用了async await语法糖，是不是比通过new Thread或Task.Run要简单多了？就像写同步代码那样，却实现了异步并发的效果。</li>
</ol>
<h2 id="一个问题">一个问题</h2>
<p>其它博客也写过示例，是控制台示例，输出的主线程ID，是有可能会变化的。这里是Winform示例，输出的主线程ID始终是UI线程的ID，即是1；<br>
我没有演示主线程ID发生变化的情况，这样会使示例变得复杂一点，不容易看明白。</p>
<h2 id="服务端">服务端</h2>
<p>服务端和客户端是两个独立的工程，测试时在一起跑，但其实可以分开部署，部署到不同的机器上<br>
服务端是一个web api接口，用.NET 6、VS2022开发，代码如下：</p>
<pre><code class="language-C#">
")]
public class TestController : ControllerBase
{
   
    ")]
    public async Task&lt;string&gt; ForPreheat()
    {
      return await Task.FromResult("预热返回结果");
    }

   
    ")]
    public async Task&lt;string&gt; Get()
    {
      await Task.Delay(2000); //模拟耗时操作
      return "测试返回结果";
    }
}
</code></pre>
<h2 id="客户端">客户端</h2>
<p>大家看客户端代码时，不需要关心服务端怎么写<br>
客户端是一个Winform工程，用.NET 6、VS2022开发，代码如下：</p>
<pre><code class="language-C#">public partial class Form1 : Form
{
    private string _urlPreheat = "http://localhost:5028/Test/ForPreheat";
    private string _url = "http://localhost:5028/Test/Get";
    private int _index1 = 1; //测试时请快速连续点击5次button1
    private int _index2 = 1; //测试时请快速连续点击5次button2
    private Stopwatch _sw1;
    private Stopwatch _sw2;

    public Form1()
    {
      InitializeComponent();
    }

    private async void Form1_Load(object sender, EventArgs e)
    {
      Request(_urlPreheat); //预热
      await RequestAsync(_urlPreheat); //预热
      Log("==== 预热请求结束 ====================================");
    }

    #region Log
    private void Log(string msg)
    {
      msg = $"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}{msg}\r\n";

      if (this.InvokeRequired)
      {
            this.BeginInvoke(new Action(() =&gt;
            {
                txtLog.AppendText(msg);
            }));
      }
      else
      {
            txtLog.AppendText(msg);
      }
    }
    #endregion

    private async void button1_Click(object sender, EventArgs e)
    {
      await Task.Delay(1000); //为了能1秒内快速点击几次，为了能写这句代码button1_Click前面加了async，但后面的代码仍是同步调用；如果不加这句，第一次点击界面就卡死了，无法连续点击5次。

      Log("==== 同步请求开始 ====================================");
      if (_index1 == 1) _sw1 = Stopwatch.StartNew();

      Request(_url);

      if (_index1 == 5)
      {
            _sw1.Stop();
            Log($"5次请求耗时：{_sw1.Elapsed.TotalSeconds:0.000}秒");
      }
      _index1++;
    }

    private async void button2_Click(object sender, EventArgs e)
    {
      await Task.Delay(1000); //为了和button1保持一致

      Log("==== 异步请求开始 ====================================");
      if (_index2 == 1) _sw2 = Stopwatch.StartNew();

      await RequestAsync(_url);

      if (_index2 == 5)
      {
            _sw2.Stop();
            Log($"5次请求耗时：{_sw2.Elapsed.TotalSeconds:0.000}秒");
      }
      _index2++;
    }

    private async Task RequestAsync(string url)
    {
      Stopwatch sw = Stopwatch.StartNew();
      HttpClient httpClient = HttpClientFactory.GetClient();
      var result = await (await httpClient.GetAsync(url)).Content.ReadAsStringAsync();
      sw.Stop();
      Log($"线程ID={Thread.CurrentThread.ManagedThreadId}，请求耗时：{sw.Elapsed.TotalSeconds:0.000}秒，返回内容长度：{result.Length}");
    }

    private void Request(string url)
    {
      Stopwatch sw = Stopwatch.StartNew();
      var result = HttpUtil.HttpGet(url);
      sw.Stop();
      Log($"线程ID={Thread.CurrentThread.ManagedThreadId}，请求耗时：{sw.Elapsed.TotalSeconds:0.000}秒，返回内容长度：{result.Length}");
    }
}
</code></pre>
<h2 id="思考">思考</h2>
<p>把button2_Click方法中的await RequestAsync(_url);修改为两行：</p>
<pre><code class="language-C#">await RequestAsync(_url);
await RequestAsync(_url);
</code></pre>
<p>那么5次点击，每次点击请求2次，共5×2=10次请求，请问这10次请求的总耗时大约是几秒？<br>
答案是4秒，为什么？<br>
因为每次点击的2次请求是顺序的，耗时是2+2=4秒，而5次点击是并发的，没有增加耗时时长</p>
<h2 id="demo完整代码">Demo完整代码</h2>
<p>https://gitee.com/s0611163/AsyncAwaitDemo2</p>
<h2 id="流程图">流程图</h2>
<p>最后，我画了两个流程图，但这两个流程图可能画的很不专业，所以仅供参考<br>
button1点击5次的流程图：<br>
<img src="https://img2023.cnblogs.com/blog/174862/202301/174862-20230130171449105-1533245885.png"><br>
button2点击5次的流程图：<br>
<img src="https://img2023.cnblogs.com/blog/174862/202301/174862-20230130171642686-2141223996.png"><br>
我之前说过，异步的本质是回调，这句话是否正确我也不知道，主要是为了大家理解异步。</p>
<h2 id="后续">后续</h2>
<p>前面测试时说了，异步不卡界面，确定不卡界面？其实没这么简单。就前面那个代码，实际应用中就卡界面了！这是怎么回事？听我仔细道来。</p>
<p>点击按钮，少量异步调用，确实不卡界面，但是我要生产模拟数据10000条，我写了个循环for(int i=0; i&lt;10000; i++)，伪代码如下：</p>
<pre><code class="language-C#">private async void btnWriteToEs_Click(object sender, EventArgs e)
{
    for (int i = 0; i &lt; 10000; i++)
    {
      await ......
    }
}
</code></pre>
<p>这样写程序是没问题，但是生产数据时，界面卡死，只是体验不好，怎么才能不卡界面呢？这样写就不卡界面了：</p>
<pre><code class="language-C#">private async void btnWriteToEs_Click(object sender, EventArgs e)
{
    await Task.Run(async () =&gt;
    {
          for (int i = 0; i &lt; 10000; i++)
          {
            await ......
            Log("xxx"); //向界面输出日志
          }
    });
}
</code></pre>
<p>除了在UI线程for循环10000次，还有一个导致界面卡的原因，就是每次await调用异步方法后，都要输出一条日志到界面上，频繁操作界面控件TextBox，肯定卡。<br>
为了向界面输出大量日志，而又不卡界面，我是这样写的：</p>
<pre><code class="language-C#">private System.Timers.Timer _timerForLog;
private ConcurrentQueue&lt;string&gt; _logMsgs = new ConcurrentQueue&lt;string&gt;();

private void Form1_Load(object sender, EventArgs e)
{
    _timerForLog = new System.Timers.Timer();
    _timerForLog.Elapsed += _timerForLog_Elapsed;
    _timerForLog.Interval = 200;
    _timerForLog.Start();
}

private void _timerForLog_Elapsed(object a, ElapsedEventArgs e)
{
    Task.Run(() =&gt;
    {
      StringBuilder sb = new StringBuilder();
      while (_logMsgs.TryDequeue(out string msg))
      {
            sb.Append(msg);
      }

      if (!this.Disposing &amp;&amp; sb.Length &gt; 0)
      {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new Action(() =&gt;
                {
                  txtLog.AppendText(sb.ToString());
                }));
            }
            else
            {
                txtLog.AppendText(sb.ToString());
            }
      }
    });
}

public void Info(string msg)
{
    Log(msg);
}

private void Log(string msg)
{
    _logMsgs.Enqueue($"{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff")}{msg}\r\n");
}
</code></pre>
<p>点击按钮，生产数据时，日志疯狂地向界面输出的时候，Winform窗体还可以拖动，其它按钮可响应点击事件。</p><br><br>
来源：https://www.cnblogs.com/s0611163/p/17076494.html
頁: [1]
查看完整版本: 通过一个示例形象地理解C# async await异步