在处理套接字耗尽和 DNS 回收时具有多个代理的 HttpClient

Question

我们正在和朋友一起做一个有趣的项目，我们必须执行数百个 HTTP 请求，所有这些请求都使用不同的代理。想象一下它是这样的：

for (int i = 0; i < 20; i++)
{
    HttpClientHandler handler = new HttpClientHandler { Proxy = new WebProxy(randomProxy, true) };

    using (var client = new HttpClient(handler))
    {
        using (var request = new HttpRequestMessage(HttpMethod.Get, "http://x.com"))
        {
            var response = await client.SendAsync(request);

            if (response.IsSuccessStatusCode)
            {
                string content = await response.Content.ReadAsStringAsync();
            }
        }

        using (var request2 = new HttpRequestMessage(HttpMethod.Get, "http://x.com/news"))
        {
            var response = await client.SendAsync(request2);

            if (response.IsSuccessStatusCode)
            {
                string content = await response.Content.ReadAsStringAsync();
            }
        }
    }
}

顺便说一下，我们使用的是 .NET Core（目前是控制台应用程序）。我知道有很多关于套接字耗尽和处理 DNS 回收的线程，但是这个特定的线程是不同的，因为使用了多个代理。

如果我们使用 HttpClient 的单例实例，就像大家建议的那样：

• 我们不能设置多个代理，因为它是在 HttpClient 实例化期间设置的，之后无法更改。
• 它不考虑 DNS 更改。重用 HttpClient 的实例意味着它会保留套接字直到它关闭，因此如果服务器上发生 DNS 记录更新，客户端将永远不会知道，直到该套接字关闭。一种解决方法是将keep-alive 标头设置为false，以便在每次请求后关闭套接字。它导致次优性能。第二种方法是使用ServicePoint：

ServicePointManager.FindServicePoint("http://x.com")  
    .ConnectionLeaseTimeout = Convert.ToInt32(TimeSpan.FromSeconds(15).TotalMilliseconds);

ServicePointManager.DnsRefreshTimeout = Convert.ToInt32(TimeSpan.FromSeconds(5).TotalMilliseconds);

另一方面，处理 HttpClient（就像我上面的示例一样），即 HttpClient 的多个实例，会导致多个套接字处于 TIME_WAIT 状态。 TIME_WAIT 表示本地端点（这边）已经关闭了连接。

我知道SocketsHttpHandler 和IHttpClientFactory，但它们无法解决不同的代理问题。

var socketsHandler = new SocketsHttpHandler
{
    PooledConnectionLifetime = TimeSpan.FromMinutes(10),
    PooledConnectionIdleTimeout = TimeSpan.FromMinutes(5),
    MaxConnectionsPerServer = 10
};

// Cannot set a different proxy for each request
var client = new HttpClient(socketsHandler);

可以做出的最明智的决定是什么？

Answer 1

重用HttpClient 实例（或者更具体地说，重用最后一个HttpMessageHandler）的重点是重用套接字连接。不同的代理意味着不同的套接字连接，因此尝试在不同代理上重用HttpClient/HttpMessageHandler 是没有意义的，因为它必须是不同的连接。

我们必须执行数百个 HTTP 请求，都使用不同的代理

如果每个请求都是真正的唯一代理，并且没有在任何其他请求之间共享代理，那么您最好保留单独的 HttpClient 实例并使用 TIME_WAIT。

但是，如果多个请求可能通过同一个代理，并且您想重用这些连接，那么这当然是可能的。

我建议使用IHttpClientFactory。它允许您定义可以合并和重用的命名HttpClient 实例（同样，技术上是最后一个HttpMessageHandler 实例）。只需为每个代理制作一个：

var proxies = new Dictionary<string, IWebProxy>(); // TODO: populate with proxies.
foreach (var proxy in proxies)
{
  services.AddHttpClient(proxy.Key)
      .ConfigurePrimaryHttpMessageHandler(() => new HttpClientHandler { Proxy = proxy.Value });
}

ConfigurePrimaryHttpMessageHandler 控制IHttpClientFactory 如何创建池化的主要HttpMessageHandler 实例。我从您问题中的代码中复制了HttpClientHandler，但大多数现代应用程序使用SocketsHttpHandler，它也有Proxy/UseProxy 属性。

然后，当你想使用一个时，调用IHttpClientFactory.CreateClient 并传递你想要的HttpClient 的名称：

for (int i = 0; i < 20; i++)
{
  var client = _httpClientFactory.CreateClient(randomProxyName);
  ...
}

Answer 2

首先，我想提一下，如果代理在编译时已知，@Stephen Cleary 的示例可以正常工作，但在我的情况下，它们在运行时已知。我忘了在问题中提到这一点，所以这是我的错。

感谢 @aepot 指出这些内容。

这就是我想出的解决方案（学分@mcont）：

/// <summary>
/// A wrapper class for <see cref="FlurlClient"/>, which solves socket exhaustion and DNS recycling.
/// </summary>
public class FlurlClientManager
{
    /// <summary>
    /// Static collection, which stores the clients that are going to be reused.
    /// </summary>
    private static readonly ConcurrentDictionary<string, IFlurlClient> _clients = new ConcurrentDictionary<string, IFlurlClient>();

    /// <summary>
    /// Gets the available clients.
    /// </summary>
    /// <returns></returns>
    public ConcurrentDictionary<string, IFlurlClient> GetClients()
        => _clients;

    /// <summary>
    /// Creates a new client or gets an existing one.
    /// </summary>
    /// <param name="clientName">The client name.</param>
    /// <param name="proxy">The proxy URL.</param>
    /// <returns>The <see cref="FlurlClient"/>.</returns>
    public IFlurlClient CreateOrGetClient(string clientName, string proxy = null)
    {
        return _clients.AddOrUpdate(clientName, CreateClient(proxy), (_, client) =>
        {
            return client.IsDisposed ? CreateClient(proxy) : client;
        });
    }

    /// <summary>
    /// Disposes a client. This leaves a socket in TIME_WAIT state for 240 seconds but it's necessary in case a client has to be removed from the list.
    /// </summary>
    /// <param name="clientName">The client name.</param>
    /// <returns>Returns true if the operation is successful.</returns>
    public bool DeleteClient(string clientName)
    {
        var client = _clients[clientName];
        client.Dispose();
        return _clients.TryRemove(clientName, out _);
    }

    private IFlurlClient CreateClient(string proxy = null)
    {
        var handler = new SocketsHttpHandler()
        {
            Proxy = proxy != null ? new WebProxy(proxy, true) : null,
            PooledConnectionLifetime = TimeSpan.FromMinutes(10)
        };

        var client = new HttpClient(handler);

        return new FlurlClient(client);
    }
}

每个请求一个代理意味着每个请求都有一个额外的套接字（另一个 HttpClient 实例）。

在上面的解决方案中，ConcurrentDictionary 用于存储 HttpClient，所以我可以重复使用它们，这就是 HttpClient 的确切点。在它被 API 限制阻止之前，我可以对 5 个请求使用相同的代理。我也忘了在问题中提到这一点。

如您所见，解决套接字耗尽和 DNS 回收问题的解决方案有两种：IHttpClientFactory 和 SocketsHttpHandler。第一个不适合我的情况，因为我使用的代理在运行时是已知的，而不是在编译时。上面的解决方案使用了第二种方式。

对于那些有同样问题的人，你可以阅读 GitHub 上的following issue。它解释了一切。

我对改进持开放态度，所以戳我。

Answer 3

将我的 cmets 收集到答案中。但这些是改进建议，而不是解决方案，因为您的问题与上下文密切相关：有多少代理，每分钟有多少请求，每个请求的平均时间是多少，等等。

声明：我不熟悉IHttpClientFactory，但我知道，这是解决 Socket 耗尽和 DNS 问题的唯一方法。

注意：ServicePointManager 不会影响 .NET Core 中的 HttpClient，因为它旨在与 .NET Core 中的 HttpClient 不使用的 HttpWebRequest 一起使用。

正如@GuruStron 所建议的，每个代理的HttpClient 实例看起来是合理的解决方案。

HttpResponseMessage 是 IDisposable。应用 using 声明。它会影响套接字的使用行为。

您可以将HttpCompletionOption.ResponseHeadersRead 申请到SendAsync 以在发送请求时不阅读整个响应。如果服务器返回不成功的状态码，您可能无法阅读响应。

为了提高内部性能，您还可以在SendAsync() 和ReadAsStringAsync() 行附加.ConfigureAwait(false)。如果当前的 SynchronizationContext 不是 null（例如，它不是控制台应用程序），这将非常有用。

这里有一些经过优化的代码（C# 8.0）：

private static async Task<string> GetHttpResponseAsync(HttpClient client, string url)
{
    using HttpResponseMessage response = await client.GetAsync(url, HttpCompletionOption.ResponseHeadersRead).ConfigureAwait(false);
    if (response.IsSuccessStatusCode)
    {
        return await response.Content.ReadAsStringAsync().ConfigureAwait(false);
    }
    return null;
}

将池化的HttpClient 和 URL 传递给方法。