Question

如果我使用Http Async而不是Sync one，我试图测量时间量的改善，但由于我搜索的异步方法上下文，下面的代码死锁，发现可以使用ConfigureAwait（false）修复情况但是代码仍然死锁。关于我如何解决这个问题的任何建议？

class Program
{
    static void Main(string[] args)
    {
        Stopwatch stopwatch = new Stopwatch();
        var entities = new List<string>() { "iron+man+3", "dark+knight+rises", "frozen+movie" };
        stopwatch.Start();
        int taskStatus = AsyncGet(entities).Result;
        stopwatch.Stop();
        Console.WriteLine(stopwatch.ElapsedTicks);
        stopwatch.Reset();
        stopwatch.Start();
        SyncGet(entities);
        stopwatch.Stop();
        Console.WriteLine(stopwatch.ElapsedTicks);
        var depTime = DateTime.UtcNow;
        depTime = depTime.AddMilliseconds(-depTime.Millisecond);
        Console.WriteLine(depTime.ToString("yyyy-MM-ddTHH:mm:ss.fff"));
        Console.Read();
    }

    private static async Task<int> AsyncGet(List<string> entities)
    {
        var taskHttpList = new List<Task<WebResponse>>();
        var taskStreamList = new List<Task<string>>();
        var uriTemplate = "https://www.google.co.in/?#q={0}";
        foreach (var entity in entities)
        {
            Uri uri = new Uri(string.Format(uriTemplate, entity));
            var request = WebRequest.Create(uri);
            taskHttpList.Add(request.GetResponseAsync());
        }
        foreach (var task1 in taskHttpList)
        {
            var response = (HttpWebResponse)await task1.ConfigureAwait(false);
            taskStreamList.Add((new StreamReader(response.GetResponseStream())).ReadToEndAsync());
        }
        foreach (var task in taskStreamList)
        {
            var responseStr = (String)await task.ConfigureAwait(false);
        }
        return 0;
    }

    private static void SyncGet(List<string> entities)
    {
        var uriTemplate = "https://www.google.co.in/?#q={0}";
        foreach (var entity in entities)
        {
            Uri uri = new Uri(string.Format(uriTemplate, entity));
            var request = WebRequest.Create(uri);
            var response = request.GetResponse();
            var str = new StreamReader(response.GetResponseStream()).ReadToEnd();
        }
    }
}

Answer 1

我认为处理IO完成事件的线程数量有限制。而不是以锁步方式处理它，而是为每个工作项构建一个完整的任务链：

 private static async Task<int> AsyncGet(List<string> entities)
 {
     var tasks = new List<Task<string>>();

      foreach (var entity in entities)
      {
        var t =  AsyncGetResponse(entity);
        tasks.Add(t); 
      }

      await Task.WaitAll(tasks.ToArray()).ConfigureAwait(false);
      return 0
  }

 static async Task<string> AsyncGetResponse(string entity)
 {
        const string uriTemplate = "https://www.google.co.in/?#q={0}";
        Uri uri = new Uri(string.Format(uriTemplate, entity));
        var request  = WebRequest.Create(uri);
        string result;

        using (var response = (HttpWebResponse)await request.GetResponseAsync().ConfigureAwait(false))
        {
            var reader = new StreamReader(response.GetResponseStream()))
            result = await (string) reader.ReadToEndAsync().ConfigureAwait(false);
        }

        return result; 

 }

正如评论中所提到的，不要忘记处理已分配的资源，例如WebResponse。

使用ConfigureAwait后，异步代码死锁（false）

1 个答案: