通过一个示例形象地理解C# async await 非并行异步、并行异步、并行异步的并发量控制

前言

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

我在 .NET与大数据中吐槽前同事在双层循环体中(肯定是单线程了)频繁请求es，导致接口的总耗时很长。这不能怪前同事，确实难写，会使代码复杂度增加。

评论区有人说他的理解是使用异步增加了系统吞吐能力，这个理解是正确的，但对于单个接口的单次请求而言，它是单线程的，耗时反而可能比同步还慢。如何缩短单个接口的单次请求的时间呢(要求：尽量不增加代码复杂度)？请看下文。

示例的测试步骤

先直接测试，看结果，下面再放代码

点击VS2022的启动按钮，启动程序，它会先启动Server工程，再启动AsyncAwaitDemo2工程
分别点击三个button
观察思考输出结果

测试截图

非并行异步(顺序执行的异步)

截图说明：单次请求耗时约0.5秒，共10次请求，耗时约 0.5秒×10=5秒

并行异步

截图说明：单次请求耗时约0.5秒，共10次请求，耗时约 0.5秒

并行异步(控制并发数量)

截图说明：单次请求耗时约0.5秒，共10次请求，并发数是5，耗时约 0.5秒×10÷5=1秒

服务端

服务端和客户端是两个独立的工程，测试时在一起跑，但其实可以分开部署，部署到不同的机器上

服务端是一个web api接口，用.NET 6、VS2022开发，代码如下：

[ApiController]

[Route("[controller]")]

public class TestController : ControllerBase

{

    [HttpGet]

    [Route("[action]")]

    public async Task<Dictionary<int, int>> Get(int i)

    {

        var result = new Dictionary<int, int>();

        await Task.Delay(500); //模拟耗时操作

        if (i == 0)

        {

            result.Add(0, 5);

            result.Add(1, 4);

            result.Add(2, 3);

            result.Add(3, 2);

            result.Add(4, 1);

        }

        else if (i == 1)

        {

            result.Add(0, 10);

            result.Add(1, 9);

            result.Add(2, 8);

            result.Add(3, 7);

            result.Add(4, 6);

        }

        return result;

    }

}

客户端

大家看客户端代码时，不需要关心服务端怎么写

客户端是一个Winform工程，用.NET 6、VS2022开发，代码如下：

public partial class Form1 : Form

{

    private readonly string _url = "http://localhost:5028/Test/Get";

    public Form1()

    {

        InitializeComponent();

    }

    private async void Form1_Load(object sender, EventArgs e)

    {

        //预热

        HttpClient httpClient = HttpClientFactory.GetClient();

        await (await httpClient.GetAsync(_url)).Content.ReadAsStringAsync();

    }

    //非并行异步(顺序执行的异步)

    private async void button3_Click(object sender, EventArgs e)

    {

        await Task.Run(async () =>

        {

            Log($"==== 非并行异步 开始，线程ID={Thread.CurrentThread.ManagedThreadId} ========================");

            Stopwatch sw = Stopwatch.StartNew();

            HttpClient httpClient = HttpClientFactory.GetClient();

            var tasks = new Dictionary<string, Task<string>>();

            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < 2; i++)

            {

                int sum = 0;

                for (int j = 0; j < 5; j++)

                {

                    Dictionary<int, int> dict = await RequestAsync(_url, i);

                    if (dict.ContainsKey(j))

                    {

                        int num = dict[j];

                        sum += num;

                        sb.Append($"{num}, ");

                    }

                }

                Log($"输出：sum={sum}");

            }

            Log($"输出：{sb}");

            sw.Stop();

            Log($"==== 结束，线程ID={Thread.CurrentThread.ManagedThreadId}，耗时：{sw.Elapsed.TotalSeconds:0.000}秒 ========================");

        });

    }

    // 并行异步

    private async void button4_Click(object sender, EventArgs e)

    {

        await Task.Run(async () =>

        {

            Log($"==== 并行异步 开始，线程ID={Thread.CurrentThread.ManagedThreadId} ========================");

            Stopwatch sw = Stopwatch.StartNew();

            HttpClient httpClient = HttpClientFactory.GetClient();

            var tasks = new Dictionary<string, Task<Dictionary<int, int>>>();

            StringBuilder sb = new StringBuilder();

            //双层循环写第一遍

            for (int i = 0; i < 2; i++)

            {

                for (int j = 0; j < 5; j++)

                {

                    var task = RequestAsync(_url, i);

                    tasks.Add($"{i}_{j}", task);

                }

            }

            //双层循环写第二遍

            for (int i = 0; i < 2; i++)

            {

                int sum = 0;

                for (int j = 0; j < 5; j++)

                {

                    Dictionary<int, int> dict = await tasks[$"{i}_{j}"];

                    if (dict.ContainsKey(j))

                    {

                        int num = dict[j];

                        sum += num;

                        sb.Append($"{num}, ");

                    }

                }

                Log($"输出：sum={sum}");

            }

            Log($"输出：{sb}");

            sw.Stop();

            Log($"==== 结束，线程ID={Thread.CurrentThread.ManagedThreadId}，耗时：{sw.Elapsed.TotalSeconds:0.000}秒 ========================");

        });

    }

    // 并行异步(控制并发数量)

    private async void button5_Click(object sender, EventArgs e)

    {

        await Task.Run(async () =>

        {

            Log($"==== 并行异步(控制并发数量) 开始，线程ID={Thread.CurrentThread.ManagedThreadId} ===================");

            Stopwatch sw = Stopwatch.StartNew();

            HttpClient httpClient = HttpClientFactory.GetClient();

            var tasks = new Dictionary<string, Task<Dictionary<int, int>>>();

            Semaphore sem = new Semaphore(5, 5);

            StringBuilder sb = new StringBuilder();

            //双层循环写第一遍

            for (int i = 0; i < 2; i++)

            {

                for (int j = 0; j < 5; j++)

                {

                    var task = RequestAsync(_url, i, sem);

                    tasks.Add($"{i}_{j}", task);

                }

            }

            //双层循环写第二遍

            for (int i = 0; i < 2; i++)

            {

                int sum = 0;

                for (int j = 0; j < 5; j++)

                {

                    Dictionary<int, int> dict = await tasks[$"{i}_{j}"];

                    if (dict.ContainsKey(j))

                    {

                        int num = dict[j];

                        sum += num;

                        sb.Append($"{num}, ");

                    }

                }

                Log($"输出：sum={sum}");

            }

            sem.Dispose(); //别忘了释放

            Log($"输出：{sb}");

            sw.Stop();

            Log($"==== 结束，线程ID={Thread.CurrentThread.ManagedThreadId}，耗时：{sw.Elapsed.TotalSeconds:0.000}秒 ========================");

        });

    }

    private async Task<Dictionary<int, int>> RequestAsync(string url, int i)

    {

        Stopwatch sw = Stopwatch.StartNew();

        HttpClient httpClient = HttpClientFactory.GetClient();

        var result = await (await httpClient.GetAsync($"{url}?i={i}")).Content.ReadAsStringAsync();

        sw.Stop();

        Log($"线程ID={Thread.CurrentThread.ManagedThreadId}，请求耗时：{sw.Elapsed.TotalSeconds:0.000}秒");

        return JsonSerializer.Deserialize<Dictionary<int, int>>(result);

    }

    private async Task<Dictionary<int, int>> RequestAsync(string url, int i, Semaphore semaphore)

    {

        semaphore.WaitOne();

        try

        {

            Stopwatch sw = Stopwatch.StartNew();

            HttpClient httpClient = HttpClientFactory.GetClient();

            var result = await (await httpClient.GetAsync($"{url}?i={i}")).Content.ReadAsStringAsync();

            sw.Stop();

            Log($"线程ID={Thread.CurrentThread.ManagedThreadId}，请求耗时：{sw.Elapsed.TotalSeconds:0.000}秒");

            return JsonSerializer.Deserialize<Dictionary<int, int>>(result);

        }

        catch (Exception ex)

        {

            Log($"错误：{ex}");

            throw;

        }

        finally

        {

            semaphore.Release();

        }

    }

    #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(() =>

            {

                txtLog.AppendText(msg);

            }));

        }

        else

        {

            txtLog.AppendText(msg);

        }

    }

    #endregion

    private void button6_Click(object sender, EventArgs e)

    {

        txtLog.Text = string.Empty;

    }

}

思考

1. Semaphore的使用要小心

这里是Winform，它是在button事件中定义的局部变量，如果是WebAPI接口，那就在接口方法中定义Semaphore局部变量。可造成别定义成全局的，或者定义成静态的，或者定义成Controller的成员变量，那样会严重限制使用它的接口的吞吐能力！
用完调用Dispose释放

2. 尽量不增加代码复杂度

请思考代码中的注释"双层循环写第一遍""双层循环写第二遍"，这个写法尽量不增加代码复杂度，试想一下，如果你用Task.Run且不说占用线程，就问你怎么写能简单？

有人说，我会，这样写不就行了：

Dictionary<int, int>[] result = await Task.WhenAll(tasks.Values);

那请问，你接下来怎么写？我相信你肯定会写，但问题是，代码的逻辑结构变了，代码复杂度增加了！

所以"双层循环写第一遍""双层循环写第二遍"是什么意思？你即能方便合并，又能方便拆分，代码逻辑结构没变，只是复制了一份。

3. RequestAsync的复杂度可控

RequestAsync的复杂度并没有因为Semaphore的引入变得更复杂，增加的代码可以接受。

我写这篇博客不是空穴来风，不只是写个Demo，我确实有实际项目中的问题需要解决，代码如下：

WebAPI的Controller层：

[HttpPost]

[Route("[action]")]

public async Task<List<NightActivitiesResultItem>> Get([FromBody] NightActivitiesPostData data)

{

    return await ServiceFactory.Get<NightActivitiesService>().Get(data.startDate, data.endDate, data.startTime, data.endTime, data.threshold, data.peopleClusters);

}

WebAPI的Service层：

public async Task<List<NightActivitiesResultItem>> Get(string strStartDate, string strEndDate, string strStartTime, string strEndTime, decimal threshold, List<PeopleCluster> peopleClusterList)

{

    List<NightActivitiesResultItem> result = new List<NightActivitiesResultItem>();

    DateTime startDate = DateTime.ParseExact(strStartDate, "yyyyMMdd", CultureInfo.InvariantCulture);

    DateTime endDate = DateTime.ParseExact(strEndDate, "yyyyMMdd", CultureInfo.InvariantCulture);

    string[][] strTimes;

    if (string.Compare(strStartTime, strEndTime) > 0)

    {

        strTimes = new string[2][] { new string[2], new string[2] };

        strTimes[0][0] = strStartTime;

        strTimes[0][1] = "235959";

        strTimes[1][0] = "000000";

        strTimes[1][1] = strEndTime;

    }

    else

    {

        strTimes = new string[1][] { new string[2] };

        strTimes[0][0] = strStartTime;

        strTimes[0][1] = strEndTime;

    }

    foreach (PeopleCluster peopleCluster in peopleClusterList)

    {

        for (DateTime day = startDate; day <= endDate; day = day.AddDays(1))

        {

            string strDate = day.ToString("yyyyMMdd");

            int sum = 0;

            foreach (string[] timeArr in strTimes)

            {

                List<PeopleFeatureAgg> list = await ServiceFactory.Get<PeopleFeatureQueryService>().QueryAgg(strDate + timeArr[0], strDate + timeArr[1], peopleCluster.ClusterIds);

                Dictionary<string, int> agg = list.ToLookup(a => a.ClusterId).ToDictionary(a => a.Key, a => a.First().Count);

                foreach (string clusterId in peopleCluster.ClusterIds)

                {

                    if (agg.TryGetValue(clusterId, out int count))

                    {

                        sum += count;

                    }

                }

            }

            if (sum >= threshold) //大于或等于阈值

            {

                NightActivitiesResultItem item = new NightActivitiesResultItem();

                item.peopleCluster = peopleCluster;

                item.date = strDate;

                item.count = sum;

                foreach (string[] timeArr in strTimes)

                {

                    PeopleFeatureQueryResult featureList = await ServiceFactory.Get<PeopleFeatureQueryService>().Query(strDate + timeArr[0], strDate + timeArr[1], peopleCluster.ClusterIds, 10000);

                    item.list.AddRange(featureList.list);

                }

                item.dataType = "xxx";

                result.Add(item);

            }

        }

    }

    var clusters = result.ConvertAll<PeopleCluster>(a => a.peopleCluster);

    await ServiceFactory.Get<PersonScoreService>().Set(OpeType.Xxx, peopleClusterList, clusters, startDate.ToString("yyyyMMddHHmmss"), endDate.ToString("yyyyMMddHHmmss"));

    return result;

}

思考

上述接口代码，它有三层循环，在第三层循环体中await，第一层循环的数量会达到1000甚至10000，第二层循环的数量会达到30(一个月30天)，甚至90(三个月)，第三层循环的数量很少。

那么总请求次数会达到3万甚至90万，如果不使用并行异步请求，那耗时将会很长。

请问：在尽量不增加代码复杂度的前提下，怎么优化，缩短该服务接口的执行时间？

我知道肯定有人要说我了，你傻啊，请求3万次？你可以改写，只请求一次，或者按天来，每天的数据只请求一次，那最多也才90次。然后在内存中计算，这不就快了？

确实是这样的，确实不应该请求3万次。但问题没这么简单：

且不说代码的复杂度，代码的复杂度你们自己想。你写的也不是一个接口，你可能会有几十个这样的接口要写，复杂度增加一点这么多接口都要写死人。
这3万请求，可都是精确查询，es强大的缓存机制，肯定会命中缓存，也就是这些请求实际上基本是直接从内存中拿数据，连遍历集合都不需要，直接命中索引。只是网络来回太多。
你这1次请求，或30次请求，对es来说，变成了范围查询，es要遍历，要给你查询并组织数据，返回集合给你。当然es集群的运算速度肯定很快。
你1次请求，或30次请求，那结果返回后，你就要在内存中计算了，我有的接口就是这样写的，但要多写代码，比如在内存中计算，为了提高效率，先创建字典相当于建索引。
只是逻辑复杂了吗？你还要多定义一些临时的变量啊！
代码写着写着就变懒了，每个接口1次请求，然后在内存中再遍历再计算，心智负担好重
我在网上看到es集群默认最多支持10000个并发查询，需要请求es的业务程序肯定不止一个，对一个业务程序而言，确实要控制并发量
根据我的观察，一个WebAPI程序，线程数一般也就几十，多的时候上百，在没有异步的时候，并发请求数量实际上受限于物理线程。
使用异步之后，并发请求数量实际上受限于虚拟线程。确实会增加请求es的并发数量，压力大的时候，这个并发数量能达到多少，还需要研究，以进一步确定，怎么限制并发数量。也许可以搞个全局的Semaphore sem = new Semaphore(500, 500);来限制一下总的es请求并发量。

怎么查看并发请求数

windows的cmd命令：

netstat -ano | findstr 5028

所以，上述并行异步不能滥用

所以，上述并行异步不能滥用，需要根据实际情况，确定，是否按这种方式优化。

还有两个问题，博客中没有体现

1. 客户端程序执行请求时，客户端线程数量

非并行异步，线程数很少了，请求开始后只增加了一两个线程。并行异步线程数较多。并行异步并控制并发量的活，线程数相对少一些。

2. Semaphore不要轻易使用

semaphore.WaitOne()阻塞线程一直阻塞到semaphore.Release()，而一个WepAPI服务程序一般也就几十上百个物理线程，想象一下，如果你这个使用semaphore的接口被大量请求，你的WebAPI程序的吞吐量会怎么样？会不会惨不忍睹。

思考

.NET只有一个CLR线程池和一个异步线程池(完成端口线程池)，当线程池中线程数量不够用时，.NET每秒才增加1到2个线程，线程增加的速度非常缓慢。结合异步，考虑一下这是为什么？

我认为(不一定对)：

异步不需要大量物理线程，少量即可
如果线程增加速度很快，以异步的吞吐量，怕不是要把es请求挂！因为并发请求数太多了。

总结

并行异步，会有并发量太大，导致诸如数据库或者es集群抗不住的问题，谨慎使用。
并行异步(控制并发数量)，并发量控制住了，但Semaphore会阻塞线程！导致整个程序的吞吐量下降。

完整测试源码

注意是AsyncParallel分支

https://gitee.com/s0611163/AsyncAwaitDemo2/tree/AsyncParallel/