使用Async和Await的ASP.NET C#5异步Web应用程序

Question

使用Async和Await的ASP.NET C#5异步Web应用程序

c#asp.netmultithreadingasynchronousasync-await

10

在研究异步Web开发概念时，特别是从这个来源，我创建了一个示例应用程序来证明这个概念。

该解决方案由2个ASP.NET Web API应用程序组成。第一个是模拟缓慢终端的应用程序；它在返回一个名为Student的自定义类列表之前等待1000ms：

 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 上，端口是 4001。

两个端点都按预期工作，并在大约 1 秒内返回。根据链接中的视频在13:25的时间点，异步方法应该释放其线程，最小化争用。

我正在使用 Apache Bench 对应用程序进行性能测试。下面是使用 10 个并发请求的同步方法的响应时间：

同步结果

这正如我预期的那样；更多的并发连接增加了争用并延长了响应时间。然而，以下是异步响应时间：

异步结果

正如您所看到的，仍然似乎存在一些争用。我希望平均响应时间更加平衡。如果我在两个端点上使用 50 个并发请求运行测试，我仍然会得到类似的结果。

基于此，似乎同步和异步方法运行速度相当（预期），未考虑异步方法中的开销，但异步方法似乎没有将线程释放回线程池。欢迎任何评论或澄清，谢谢。

- Paul Mooney

1

异步框架的目的是在等待响应时释放线程，以便同时处理其他工作。这通常适用于基于IO的请求。当您从数据库请求大量数据时，线程应该同时做什么？只是等待数据返回...还是返回到线程池，同时处理其他事情，直到数据返回？ - JustAnotherUserYouMayKnow

@DaveVandenEynde 那不会影响客户端应用程序的行为。 - svick

1

另外，你的async方法实际上并不完全是异步的，你应该使用ReadToEndAsync()。 - svick

@svick，另外，我正在本地机器上运行测试 - 即使是50个并发请求，也需要大约1分钟才能完成。我意识到在服务器上，我们预计会有更高的吞吐量，因此这些数字似乎对于本地测试是足够的。 - Paul Mooney

顺便问一下，在异步请求期间，当IIS将线程返回到线程池时，管理回调的状态机运行在哪些线程上？它是由IIS托管的，如果是这样，它是否也利用了线程池，还是在IIS之外的操作系统线程上运行？ - Paul Mooney

显示剩余6条评论

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Stephen Cleary · Accepted Answer

我认为你测试的可能不是你所想的。据我所知，你正在尝试通过比较时间和推断线程注入来检测返回给线程池的发布。

首先，在.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

这清楚地表明异步方法正在将其线程返回到线程池中。