研究异步Web开发的概念,特别是从
this源代码,我创建了一个示例应用程序来证明这个概念.
该解决方案由2个ASP.NET Web API应用程序组成.第一个是模拟慢端点;它等待1000 ms,然后返回一个名为Student的自定义类列表：
public IEnumerable<Student> Get()
{
Thread.Sleep(1000);
return new List<Student> { new Student { Name = @"Paul" },new Student { Name = @"Steve" },new Student { Name = @"Dave" },new Student { Name = @"Sue" } };
}
这是学生班：
public class Student
{
public string Name { get; set; }
}
此端点托管在本地主机上的IIS 7中：4002.
第二个应用程序联系第一个使用2个端点,一个同步,另一个异步：
public IEnumerable<Student> Get() {
var proxy = WebRequest.Create(@"http://localhost:4002/api/values");
var response = proxy.GetResponse();
var reader = new StreamReader(response.GetResponseStream());
return JsonConvert.DeserializeObject<IEnumerable<Student>>(reader.ReadToEnd());
}
public async Task<IEnumerable<Student>> Get(int id) {
var proxy = new HttpClient();
var getStudents = proxy.GetStreamAsync(@"http://localhost:4002/api/values");
var stream = await getStudents;
var reader = new StreamReader(stream);
return JsonConvert.DeserializeObject<IEnumerable<Student>>(reader.ReadToEnd());
}
它在IIS 7上托管在localhost：4001上.
两个端点都按预期工作,并返回约1秒.基于上面13:25链接的视频,异步方法应该释放它的线程,最小化争用.
我正在使用Apache Bench对应用程序进行性能测试.以下是10个并发请求的同步方法的响应时间：
这是我所期望的那么多更多并发连接增加争用并延长响应时间.但是,这里是异步响应时间：
正如你所看到的,似乎还有一些争论.我预计平均响应时间会更加平衡.如果我在具有50个并发请求的两个端点上运行测试,我仍然得到类似的结果.
基于此,似乎异步和同步方法都以或多或少的速度运行(预期),而不考虑异步方法中的开销,而且异步方法似乎没有释放线程返回到ThreadPool.谢谢任何意见或澄清.
解决方法
我认为有一个很好的机会,你没有测试你认为你正在测试.从我可以收集的内容中,您将通过比较时间和推断线程注入来尝试检测到线程池的发布.
首先,.NET 4.5上的线程池的默认设置非常高.你不会打10个或100个同时发出的请求.
回过头一下,想想你想要测试的内容：一个异步方法是否将线程返回给线程池？
我有一个我演示的演示来证明这一点.我不想为我的演示(在我的演示文稿笔记本电脑上运行)创建一个沉重的负载测试,所以我拉了一个小技巧：我人为地限制线程池更合理的价值.
一旦你这样做,你的测试是非常简单的：执行许多同时连接,然后执行许多加一.在启动最后一个之前,同步实现将不得不等待一个完成,而异步实现将能够启动它们.
在服务器端,首先将线程池线程限制为系统中的处理器数量：
protected void Application_Start()
{
int workerThreads,ioThreads;
ThreadPool.GetMaxThreads(out workerThreads,out ioThreads);
ThreadPool.SetMaxThreads(Environment.ProcessorCount,ioThreads);
...
}
然后执行同步和异步实现：
public class ValuesController : ApiController
{
// Synchronous
public IEnumerable<string> Get()
{
Thread.Sleep(1000);
return new string[] { "value1","value2" };
}
// Asynchronous
public async Task<IEnumerable<string>> Get(int id)
{
await Task.Delay(1000);
return new string[] { "value1","value2" };
}
}
最后客户端测试代码：
static void Main(string[] args)
{
try
{
MainAsync().Wait();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
Console.ReadKey();
}
static async Task MainAsync()
{
ServicePointManager.DefaultConnectionLimit = int.MaxValue;
var sw = new Stopwatch();
var client = new HttpClient();
var connections = Environment.ProcessorCount;
var url = "http://localhost:35697/api/values/";
await client.GetStringAsync(url); // warmup
sw.Start();
await Task.WhenAll(Enumerable.Range(0,connections).Select(i => client.GetStringAsync(url)));
sw.Stop();
Console.WriteLine("Synchronous time for " + connections + " connections: " + sw.Elapsed);
connections = Environment.ProcessorCount + 1;
await client.GetStringAsync(url); // warmup
sw.Restart();
await Task.WhenAll(Enumerable.Range(0,connections).Select(i => client.GetStringAsync(url)));
sw.Stop();
Console.WriteLine("Synchronous time for " + connections + " connections: " + sw.Elapsed);
url += "13";
connections = Environment.ProcessorCount;
await client.GetStringAsync(url); // warmup
sw.Restart();
await Task.WhenAll(Enumerable.Range(0,connections).Select(i => client.GetStringAsync(url)));
sw.Stop();
Console.WriteLine("Asynchronous time for " + connections + " connections: " + sw.Elapsed);
connections = Environment.ProcessorCount + 1;
await client.GetStringAsync(url); // warmup
sw.Restart();
await Task.WhenAll(Enumerable.Range(0,connections).Select(i => client.GetStringAsync(url)));
sw.Stop();
Console.WriteLine("Asynchronous time for " + connections + " connections: " + sw.Elapsed);
}
在我的(8逻辑核心)机器上,我看到这样的输出：
Synchronous time for 8 connections: 00:00:01.0194025 Synchronous time for 9 connections: 00:00:02.0362007 Asynchronous time for 8 connections: 00:00:01.0413737 Asynchronous time for 9 connections: 00:00:01.0238674
这清楚地表明异步方法将其线程返回到线程池.
