await async能提升什么？和Task有什么区别？

曾经终败给现在 2022-10-05 14:56 162阅读 0赞

### 目录 ###

*   *  介绍
     *  测试读取本地文件能力
     *   *  总结
     *  测试请求网络
     *   *  总结
     *  分析总结

## 介绍 ##

我们在使用task和await async时总会产生纠结，都同样是开线程用哪个合适呢，await async是会提升**性能**还是提升**吞吐量**呢？。  
先说一下**性能**的问题，await是串行的，肯定没有非串行的性能好。而吞吐呢？吞吐就是在1s内能处理多少个请求，当然主要针对Web模式。一下测试会解决证明这个问题

## 测试读取本地文件能力 ##

准备了一个300M文件，使用Task，await async，sync的方式分别进行10次读取，统计耗时和线程的使用情况

#region ReadFile
    { 
        Console.WriteLine("******************ReadFile***************");
        string path = "D:\\test.7z";
        int loopNum = 10;//30
        { 
            Console.WriteLine("*****************Async****************");
            List<Task> taskList = new List<Task>();
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < loopNum; i++)
            { 
                taskList.Add(ReadAsync(path, i));
            }
            Task.WaitAll(taskList.ToArray());
            stopwatch.Stop();
            Console.WriteLine($"Async耗时{ stopwatch.ElapsedMilliseconds}ms,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        }
        Thread.Sleep(3000);
        { 
            Console.WriteLine("*****************Task****************");
            List<Task> taskList = new List<Task>();
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < loopNum; i++)
            { 
                taskList.Add(ReadTask(path, i));
            }
            Task.WaitAll(taskList.ToArray());
            stopwatch.Stop();
            Console.WriteLine($"Task耗时{ stopwatch.ElapsedMilliseconds}ms,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        }
        Thread.Sleep(3000);
        { 
            Console.WriteLine("*****************Sync****************");
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < loopNum; i++)
            { 
                ReadSync(path, i);
            }
            stopwatch.Stop();
            Console.WriteLine($"Sync耗时{ stopwatch.ElapsedMilliseconds}ms,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        }
    }
    #endregion

#region Read
    private static async Task<byte[]> ReadAsync(string path, int num)
    { 
        Console.WriteLine($"This is ReadAsync{ num} Start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        var result = await File.ReadAllBytesAsync(path);
        Console.WriteLine($"This is ReadAsync{ num} End,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        return result;
    }
    
    private static Task<byte[]> ReadTask(string path, int num)
    { 
        Console.WriteLine($"This is ReadTask{ num} Start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        var result = Task.Run(() =>
        { 
            Console.WriteLine($"This is ReadTask Ing,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
            return File.ReadAllBytes(path);
        });
        Console.WriteLine($"This is ReadTask{ num} End,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        return result;
    }
    
    private static byte[] ReadSync(string path, int num)
    { 
        Console.WriteLine($"This is ReadSync{ num} Start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        var result = File.ReadAllBytes(path);
        Console.WriteLine($"This is ReadSync{ num} End,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        return result;
    }
    #endregion

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 1]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 2]

### 总结 ###

*  Async: 可以并发，但是并发不多，耗时1839
 *  Task：启动10个线程，并发10个线程，很正常，耗时2310
 *  Sync：同步方法，按顺序执行非常的稳，耗时5163

## 测试请求网络 ##

准备一个api项目，运行代码很简单，只是休眠一下。使用Task，await async，sync的方式分别进行10次读取，统计耗时和线程的使用情况

public IActionResult Sleep(string type, int loop, int second)
     { 
         Console.WriteLine($"This is { type},{ loop} times start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
         Thread.Sleep(second * 1000);
         Console.WriteLine($"This is { type},{ loop} times end,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
         return View();
     }

#region InvokeWeb
    { 
        Console.WriteLine("******************InvokeWeb***************");
        string url = "http://localhost:8080/home/Sleep";
        int loopNum = 10;//5
        int second = 5;
        { 
            Console.WriteLine("*****************Async****************");
            List<Task> taskList = new List<Task>();
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < loopNum; i++)
            { 
                taskList.Add(WebAsync(url, i, second));
            }
            Task.WaitAll(taskList.ToArray());
            stopwatch.Stop();
            Console.WriteLine($"Async耗时{ stopwatch.ElapsedMilliseconds}ms,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        }
        
        Thread.Sleep(3000);
        { 
            Console.WriteLine("*****************Task****************");
            List<Task> taskList = new List<Task>();
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < loopNum; i++)
            { 
                taskList.Add(WebTask(url, i, second));
            }
            Task.WaitAll(taskList.ToArray());
            stopwatch.Stop();
            Console.WriteLine($"Task耗时{ stopwatch.ElapsedMilliseconds}ms,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        }
        Thread.Sleep(3000);
        { 
            Console.WriteLine("*****************Sync****************");
            Stopwatch stopwatch = new Stopwatch();
            stopwatch.Start();
            for (int i = 0; i < loopNum; i++)
            { 
                WebSync(url, i, second);
            }
            stopwatch.Stop();
            Console.WriteLine($"Sync耗时{ stopwatch.ElapsedMilliseconds}ms,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        }
    }
    #endregion

#region InvokeWebRequest 
    private static string InvokeWebRequest(string url)
    { 
           string html = null;
           try
           { 
               HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;//模拟请求
               request.Timeout = 30 * 1000;//
               using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)//发起请求
               { 
                   if (response.StatusCode != HttpStatusCode.OK)
                   { 
                       Console.WriteLine($"抓取{ url}地址返回失败,response.StatusCode为{ response.StatusCode}");
                   }
                   else
                   { 
                       StreamReader sr = new StreamReader(response.GetResponseStream());
                       html = sr.ReadToEnd();//读取数据
                   }
               }
           }
           catch (WebException ex)
           { 
               if (ex.Message.Equals("远程服务器返回错误: (306)。"))
               { 
                   Console.WriteLine($"抓取{ url}地址返回失败,远程服务器返回错误: (306)");
                   html = null;
               }
           }
           catch (Exception ex)
           { 
               Console.WriteLine($"抓取{ url}地址返回失败,远程服务器返回错误{ ex.Message}");
               html = null;
           }
           return html;
      }	
    
    private static async Task<string> InvokeWebRequestAsync(string url)
    { 
        string html = null;
        try
        { 
            HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;//模拟请求
            request.Timeout = 30 * 1000;//
            using (HttpWebResponse response = (await request.GetResponseAsync()) as HttpWebResponse)//发起请求
            { 
                if (response.StatusCode != HttpStatusCode.OK)
                { 
                    Console.WriteLine($"抓取{ url}地址返回失败,response.StatusCode为{ response.StatusCode}");
                }
                else
                { 
                    StreamReader sr = new StreamReader(response.GetResponseStream());
                    return await sr.ReadToEndAsync();//异步
                }
            }
        }
        catch (WebException ex)
        { 
            if (ex.Message.Equals("远程服务器返回错误: (306)。"))
            { 
                Console.WriteLine($"抓取{ url}地址返回失败,远程服务器返回错误: (306)");
                html = null;
            }
        }
        catch (Exception ex)
        { 
            Console.WriteLine($"抓取{ url}地址返回失败,远程服务器返回错误{ ex.Message}");
            html = null;
        }
        return html;
    }
       
    private static async Task<string> WebAsync(string url, int num, int second)
    { 
        url = $"{ url}?loop={ num}&type=Async&second={ second}";
        Console.WriteLine($"This is InvokeAsync{ url} Start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        var result = await InvokeWebRequestAsync(url);
        Console.WriteLine($"This is InvokeAsync{ url} End,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        return result;
    }
    
    private static Task<string> WebTask(string url, int num, int second)
    { 
        url = $"{ url}?loop={ num}&type=Task&second={ second}";
        Console.WriteLine($"This is WebTask{ num} Start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        var result = Task.Run(() =>
        { 
            Console.WriteLine($"This is WebTask Ing,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
            return InvokeWebRequest(url);
        });
        Console.WriteLine($"This is WebTask{ num} End,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        return result;
    }
    private static string WebSync(string url, int num, int second)
    { 
        url = $"{ url}?loop={ num}&type=Sync&second={ second}";
        Console.WriteLine($"This is WebSync{ num} Start,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        var result = InvokeWebRequest(url);
        Console.WriteLine($"This is WebSync{ num} End,ThreadId={ Thread.CurrentThread.ManagedThreadId}");
        return result;
    }
    #endregion

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 3]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 4]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 5]

### 总结 ###

*  Async：并发高，速度快，可以使用较少的线程还不影响并发，而且线程能重用，利用率高(虽然没测试出来，但确实会重用)，耗时5505
 *  Task：耗时长一些，并发没有async高，说开10个线程，就是10个线程，耗时5641
 *  Sync：串行的，耗时长，一如既往的稳，耗时50105

## 分析总结 ##

先分析前需要了解一下DMA技术，我们经常能看见框架封装的与第三方交互的（非托管资源）方法里有async的版本。接下来我大概解释一下这个DMA技术：

拿硬盘举例：比如软件想读取硬盘里的数据，那么流程是这样的

1.  软件线程告诉硬盘：我要取东西
2.  线程忙其他事情，硬盘接收命令后独自执行
3.  硬盘执行完毕，发送中断信号，通知线程
4.  线程收到通知，继续处理  
    这就基于DMA的异步操作，就是可以节约CPU资源(线程)，避免了线程浪费。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 6]

*  Task 并没有DMA技术加持，是真的10个线程在等待信息回复。
 *  await async有DMA技术加持，只需要发送一个命令，不需要线程等待，等await结束再继续处理而且还可以实现线程重用，减少了资源浪费。所以能提升吞吐量。而await是串行的运行方式所以不存在提升性能一说，但确实能提升吞吐量。  
            但await async 也不是万能的，如果需要密集型计算时（需要时刻自己计算，不能使用DMA托管），没有办法对线程进行节约的情况使用它是没有什么价值，而且可能会有些小问题，目前但问题不大因为这个技术已经非常成熟。所以全文都这样写也不会有什么问题。当我们进行密集计算测试时会发现await async在申请线程时会比Task快一点，但这很明显没什么意义，因为await async不能进程托管时节省这些都没有意义。最后建议大家直接无脑await async就行了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70]: /images/20221005/1d09459d13b747729363c0689cd8746a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 1]: /images/20221005/8218e085d25e4f35b79ea86772bcf37c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 2]: /images/20221005/230b114ad06741eba1781ca3a9e0cabb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 3]: /images/20221005/56efd3b09ecb4f829aab9a273ff54682.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 4]: /images/20221005/080233e8feee46b6adfb4f9d672b3d16.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 5]: /images/20221005/0742253a9e4d4dfe90f87c6e5605a81e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3R4MTcyMTExMDI0MA_size_16_color_FFFFFF_t_70 6]: /images/20221005/2b35ee908e3943e48355def1965588e5.png