HttpClient 查询偶尔挂起

Question

我像这样初始化HttpClient：

public static CookieContainer cookieContainer = new CookieContainer();
public static HttpClient httpClient = new HttpClient(new HttpClientHandler() { AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate, CookieContainer = cookieContainer }) { Timeout = TimeSpan.FromSeconds(120) };

所以如果在 120 秒内没有收到响应，所有查询都应该抛出 TaskCanceledException。 但有些查询（例如 1 万个 100 000-1 000 000 个）会无限挂起。

我写了以下代码：

public static async Task<HttpResponse> DownloadAsync2(HttpRequestMessage httpRequestMessage)
{
    HttpResponse response = new HttpResponse { Success = false, StatusCode = (int)HttpStatusCode.RequestTimeout, Response = "Timeout????????" };
    Task task;
    if (await Task.WhenAny(
        task = Task.Run(async () =>
        {
            try
            {
                HttpResponseMessage r = await Global.httpClient.SendAsync(httpRequestMessage).ConfigureAwait(false);
                response = new HttpResponse { Success = true, StatusCode = (int)r.StatusCode, Response = await r.Content.ReadAsStringAsync().ConfigureAwait(false) };
            }
            catch (TaskCanceledException)
            {
                response = new HttpResponse { Success = false, StatusCode = (int)HttpStatusCode.RequestTimeout, Response = "Timeout" };
            }
            catch (Exception ex)
            {
                response = new HttpResponse { Success = false, StatusCode = -1, Response = ex.Message + ": " + ex.InnerException };
            }
        }),
        Task.Run(async () =>
        {
            await Task.Delay(TimeSpan.FromSeconds(150)).ConfigureAwait(false);
        })
    ).ConfigureAwait(false) != task)
    {
        Log("150 seconds passed");
    }
    return response;
}

实际上偶尔会执行Log("150 seconds passed");。

我这样称呼它：

HttpResponse r = await DownloadAsync2(new HttpRequestMessage
{
    RequestUri = new Uri("https://address.com"),
    Method = HttpMethod.Get
}).ConfigureAwait(false);

为什么 TaskCanceledException 有时在 120 秒后不抛出？

Answer 1

我不知道你调用DownloadAsync2 的频率有多高，但你的代码对于线程池的爆裂和饥饿来说很臭。

默认情况下，ThreadPool 中的初始线程数限制为 CPU 逻辑内核数（对于当今的正常系​​统通常为 12 个），如果 ThreadPool 中的线程不可用，则生成每个新线程需要 500 毫秒。

例如：

for (int i = 0; i < 1000; i++)
{
    HttpResponse r = await DownloadAsync2(new HttpRequestMessage
    {
        RequestUri = new Uri("https://address.com"),
        Method = HttpMethod.Get
    }).ConfigureAwait(false);
}

这段代码很有可能会被冻结，特别是如果您的代码中有一些lock 或任何cpu intensive 任务。因为您每次调用 DownloadAsync2 都会调用新线程，所以 ThreadPool 的所有线程都已消耗，并且仍然需要更多线程。

我知道你可能会说“我的所有任务都已等待，它们已发布以用于其他工作”。但它们也用于启动新的DownloadAsync2 线程，您将达到在完成await Global.httpClient.SendAsync 后没有线程可用于重新分配和完成任务的地步。

所以方法必须等到一个线程可用或生成完成（即使在超时之后）。罕见但可行。

Answer 2

在 Windows 和 .NET 上，对同一端点的并发传出 HTTP 请求数限制为 2（根据 HTTP 1.1 规范）。如果您向同一端点创建大量并发请求，它们将排队。这是您所经历的一种可能的解释。

另一种可能的解释是：您没有明确设置 HttpClient 的 Timeout 属性，因此它默认为 100 秒。如果你不断地发出新的请求，而之前的请求没有完成，系统资源就会被耗尽。

我建议将 Timeout 属性设置为较低的值 - 与您拨打电话的频率（1 秒？）成正比，并可选择增加与 ServicePointManager.DefaultConnectionLimit 的并发传出连接数

Answer 3

我发现它是 httpClient.SendAsync 方法偶尔会挂起。因此，我添加了一个设置为 X 秒的取消令牌。但即使使用取消令牌，它有时也可能会卡住并且永远不会抛出 TaskCanceledException。

因此，我着手解决使 SendAsync 任务永远停留在后台并继续其他工作的解决方法。

这是我的解决方法：

public static async Task<Response> DownloadAsync3(HttpRequestMessage httpRequestMessage, string caller)
{
    Response response;
    try
    {
        using CancellationTokenSource timeoutCTS = new CancellationTokenSource(httpTimeoutSec * 1000);
        using HttpResponseMessage r = await Global.httpClient.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseContentRead, timeoutCTS.Token).WithCancellation(timeoutCTS.Token).ConfigureAwait(false);
        response = new Response { Success = true, StatusCode = (int)r.StatusCode, Message = await r.Content.ReadAsStringAsync().ConfigureAwait(false) };
    }
    catch (TaskCanceledException)
    {
        response = new Response { Success = false, StatusCode = (int)HttpStatusCode.RequestTimeout, Message = "Timeout" };
    }
    catch (Exception ex)
    {
        response = new Response { Success = false, StatusCode = -1, Message = ex.Message + ": " + ex.InnerException };
    }
    httpRequestMessage.Dispose();
    return response;
}

public static Task<T> WithCancellation<T>(this Task<T> task, CancellationToken cancellationToken)
{
    return task.IsCompleted
        ? task
        : task.ContinueWith(
            completedTask => completedTask.GetAwaiter().GetResult(),
            cancellationToken,
            TaskContinuationOptions.ExecuteSynchronously,
            TaskScheduler.Default);
}

Answer 4

使用Flurl，您可以为每个客户端、每个请求或全局配置超时。

// call once at application startup
FlurlHttp.Configure(settings => settings.Timeout = TimeSpan.FromSeconds(120));

string url = "https://address.com";

// high level scenario
var response = await url.GetAsync();

// low level scenario
await url.SendAsync(
    HttpMethod.Get, // Example
    httpContent, // optional
    cancellationToken,  // optional
    HttpCompletionOption.ResponseHeaderRead);  // optional

// Timeout at request level
await url
    .WithTimeout(TimeSpan.FromSeconds(120))
    .GetAsync();

Fluent HTTP documentation

Flurl configuration documentation

Answer 5

答案是：

ThreadPool.SetMinThreads(MAX_THREAD_COUNT, MAX_THREAD_COUNT);

其中 MAX_THREAD_COUNT 是某个数字（我使用 200）。您必须至少设置第二个参数（completionPortThreads），并且很可能是第一个（workerThreads）。我已经设置了第一个，但没有设置第二个，现在它正在工作，我保持两个设置。

唉，这不是答案。见下面的cmets

Answer 6

好吧，我正式放弃了！我将代码替换为：

    try
    {
        return Task.Run(() => httpClient.SendAsync(requestMessage)).Result;
    }
    catch (AggregateException e)
    {
        if (e.InnerException != null)
            throw e.InnerException;
        throw;
    }