使用F5负载均衡器创建多HttpClient连接时遇SocketError问题求助

你遇到的这个问题我之前在处理企业级服务调用时也碰到过——通过F5负载均衡批量发起长耗时请求时，单个请求超时触发Socket异常导致整个进程终止，但单实例调用却正常。结合你的代码来看，核心问题出在HttpClient的滥用和异步任务的异常处理上，完全可以通过代码优化解决，同时配合F5的小调整就能彻底搞定。

一、代码里的核心问题 #

1. 每次请求创建新HttpClient，导致Socket资源耗尽 #

你的PostAsync方法每次都新建HttpClientHandler和HttpClient，这是.NET HttpClient使用的大忌。频繁创建HttpClient会导致大量Socket连接处于TIME_WAIT状态，批量并发时很容易耗尽Socket资源，加上F5的空闲连接超时机制，就会触发Socket异常。

2. 同步阻塞等待+未处理的异常导致进程终止 #

外层循环用Task.WaitAll同步等待任务完成，一旦有任务抛出异常（比如Socket断开），WaitAll会直接抛出AggregateException，如果这个异常没有被捕获，整个进程就会直接终止。而且你设置了HttpClient.Timeout = Timeout.InfiniteTimeSpan，和F5的超时配置不匹配，F5主动断开连接后客户端还在傻等，必然出问题。

二、具体代码修改方案 #

1. 重构HttpClient为复用模式（关键！） #

改用单例HttpClient或者IHttpClientFactory（.NET Core/.NET 5+推荐），避免重复创建连接。这里给出单例注入的实现：

public class Service2: IService2
{
    private readonly HttpClient _httpClient;
    private readonly string _service2BaseUrl;
    private readonly string _acceptedThumbprint;
    private readonly string _signatureKey;
    private readonly string _authUserName;

    // 通过构造函数注入必要配置和HttpClient
    public Service2(HttpClient httpClient, 
                   string service2BaseUrl, 
                   string acceptedThumbprint,
                   string signatureKey,
                   string authUserName)
    {
        _httpClient = httpClient;
        _service2BaseUrl = service2BaseUrl;
        _acceptedThumbprint = acceptedThumbprint;
        _signatureKey = signatureKey;
        _authUserName = authUserName;

        // 初始化默认请求头，只做一次
        _httpClient.DefaultRequestHeaders.Accept.Clear();
        _httpClient.DefaultRequestHeaders.Accept.Add(ResponseFormatter.MediaType);
        // 设置合理的超时，要比F5的空闲超时短一点（比如F5设为65分钟，这里设60分钟）
        _httpClient.Timeout = TimeSpan.FromMinutes(60);

        // 配置SSL证书验证，只做一次
        var handler = _httpClient.GetHandler() as HttpClientHandler;
        if (handler != null)
        {
            handler.ServerCertificateCustomValidationCallback = (message, cert, chain, sslPolicyErrors) =>
            {
                if (sslPolicyErrors == SslPolicyErrors.None)
                    return true;
                return cert.GetCertHashString().Equals(_acceptedThumbprint, StringComparison.OrdinalIgnoreCase);
            };
        }
    }

    public async Task Service2MethodCall(ClassC service2Input, string resource)
    {
        try
        {
            var uri = BuildUri(resource);
            var jsonContent = new StringContent(JsonConvert.SerializeObject(service2Input), 
                                               Encoding.UTF8, 
                                               "application/json");

            // 添加授权头（注意每次请求要重新生成，因为uri和数据可能变）
            if (!string.IsNullOrWhiteSpace(_signatureKey))
            {
                var authHeader = RequestFormatter.GenerateAuthHeaderEncodedUserSignature(uri, 
                                                                                        _authUserName, 
                                                                                        _signatureKey, 
                                                                                        service2Input);
                _httpClient.DefaultRequestHeaders.Remove("Authorization");
                _httpClient.DefaultRequestHeaders.TryAddWithoutValidation("Authorization", authHeader);
            }

            HttpResponseMessage response = await _httpClient.PostAsync(uri, jsonContent);
            string content = await response.Content.ReadAsStringAsync();
            
            // 检查响应状态
            try
            {
                response.EnsureSuccessStatusCode();
            }
            catch (HttpRequestException)
            {
                var reqId = service2Input.RecsList.FirstOrDefault(x => !string.IsNullOrEmpty(x.ReqId))?.ReqId ?? "Unknown";
                throw new ApiHttpException(response.StatusCode, $"Failed for Req ID {reqId}: {content}");
            }
        }
        catch (Exception ex)
        {
            var reqId = service2Input.RecsList.FirstOrDefault(x => !string.IsNullOrEmpty(x.ReqId))?.ReqId ?? "Unknown";
            throw new Exception($"Error calling Service2 for Req ID {reqId}", ex);
        }
    }

    private Uri BuildUri(string resource)
    {
        return new Uri($"{_service2BaseUrl.TrimEnd('/')}/{resource.TrimStart('/')}");
    }
}

2. 优化批量调用逻辑，正确处理异步异常 #

把同步的Task.WaitAll改成异步的await Task.WhenAll，并捕获异常避免进程终止：

public async Task ProcessRequestsAsync(List<ClassA> reqList, List<ClassA> allRecs)
{
    const int batchSize = 10;
    var pendingTasks = new List<Task>();

    for (int i = 0; i < reqList.Count; i++)
    {
        var currentReq = reqList[i];
        var recsForReq = allRecs.Where(x => x.ReqId == currentReq.ReqtId).ToList();
        
        var serviceInput = new ClassC
        {
            DetaiList = listofRecs, // 确保这个变量在当前作用域可用
            RecList = recsForReq
        };

        // 添加任务，同时可以单独捕获单个任务的异常
        var callTask = _service2.Service2MethodCall(serviceInput, service2Resource)
            .ContinueWith(task =>
            {
                if (task.IsFaulted)
                {
                    // 这里记录日志，不要直接抛出，避免影响整个批次
                    // _logger.LogError(task.Exception, "Failed to call Service2 for Req ID {ReqId}", currentReq.ReqtId);
                }
            }, TaskContinuationOptions.OnlyOnFaulted);
        
        pendingTasks.Add(callTask);

        // 达到批量大小或者最后一个请求时，等待所有任务完成
        if (pendingTasks.Count == batchSize || i == reqList.Count - 1)
        {
            try
            {
                await Task.WhenAll(pendingTasks);
            }
            catch (AggregateException ex)
            {
                // 遍历所有异常并记录，不要让进程终止
                foreach (var innerEx in ex.InnerExceptions)
                {
                    // _logger.LogError(innerEx, "Batch request failed");
                }
                // 如果需要终止流程，取消下面的注释；否则继续处理下一批
                // throw;
            }
            pendingTasks.Clear();
        }
    }
}

三、F5配置配合建议 #

虽然代码优化能解决核心问题，但配合F5调整会更稳定：

• 调整空闲连接超时：把F5的Idle Timeout设置为比HttpClient超时更长的时间（比如HttpClient设60分钟，F5设65分钟），避免F5主动断开长连接。
• 开启TCP Keep-Alive：在F5上启用TCP Keep-Alive，保持连接活跃，防止长耗时请求期间连接被断开。

总结 #

通过复用HttpClient解决Socket资源泄漏问题，异步等待+异常捕获避免进程终止，再配合F5的超时配置调整，完全可以彻底解决你遇到的问题。

内容的提问来源于stack exchange，提问作者WorksOnMyLocal