HttpWebRequest正确释放与高频批量请求内存问题技术问询

看了你的代码和问题描述，核心问题出在资源未正确释放和请求并发控制不严谨上，加上Timer高频触发导致大量未完成请求堆积，最终引发非托管内存占用飙升。下面给你一套完整的修复方案，兼顾资源释放、并发控制和批量执行的需求：

一、现有代码的核心问题 #

• 所有实现IDisposable的对象（HttpWebRequest、HttpWebResponse、StreamReader）都没有用using语句包裹，导致非托管资源（如底层Socket连接、流）无法及时回收。
• 用Thread手动开启后台线程的方式既低效又难以管理，而且UI线程的InvokeRequired判断逻辑写反了（应该是InvokeRequired为true时Invoke，false时直接执行，你现在的逻辑搞反了）。
• Timer每150ms就触发一次请求，没有做并发限制，即使设了ServicePointManager.DefaultConnectionLimit，也会因为请求堆积导致大量未释放的连接资源。

二、修复后的完整方案 #

1. 重构请求逻辑，强制资源自动释放 #

使用using语句确保所有可释放对象在使用完毕后立即释放，这是解决非托管内存泄漏的关键：

// 异步请求方法，返回响应内容
private async Task<string> SendRequestAsync(string url, IWebProxy proxy)
{
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
    request.AllowAutoRedirect = true;
    request.KeepAlive = true;
    request.Proxy = proxy;
    request.Method = "GET";

    try
    {
        using (HttpWebResponse response = (HttpWebResponse)await request.GetResponseAsync())
        using (Stream responseStream = response.GetResponseStream())
        using (StreamReader reader = new StreamReader(responseStream, Encoding.UTF8, true))
        {
            return await reader.ReadToEndAsync();
        }
    }
    catch (Exception ex)
    {
        ProjectData.SetProjectError(ex);
        // 这里可以根据需求添加错误日志或处理逻辑
        ProjectData.ClearProjectError();
        return null;
    }
}

2. 实现并发控制与批量执行 #

用SemaphoreSlim来限制同时执行的请求数量，比单纯依赖ServicePointManager.DefaultConnectionLimit更灵活可控：

// 并发信号量，限制同时执行的请求数，可根据服务器承受能力调整
private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(100);
// 标记是否正在执行批量请求，避免Timer重叠触发
private bool _isProcessing = false;

private async void timer1_Tick(object sender, EventArgs e)
{
    // 如果正在处理，直接返回，避免重叠
    if (_isProcessing) return;
    _isProcessing = true;

    try
    {
        // 示例：批量执行10个请求，你可以根据需求调整批量大小
        List<Task<string>> tasks = new List<Task<string>>();
        for (int i = 0; i < 10; i++)
        {
            await _semaphore.WaitAsync();
            // 将请求包装成异步任务，执行后释放信号量
            tasks.Add(Task.Run(async () =>
            {
                try
                {
                    return await SendRequestAsync(myUrl, webProxy);
                }
                finally
                {
                    _semaphore.Release();
                }
            }));
        }

        // 等待所有批量请求完成
        await Task.WhenAll(tasks);

        // 这里可以处理所有请求的返回结果
        foreach (var task in tasks)
        {
            string result = task.Result;
            // 处理结果逻辑...
        }
    }
    finally
    {
        _isProcessing = false;
    }
}

3. 初始化配置优化 #

在程序启动时设置必要的全局配置，配合并发控制：

// 在程序初始化时（比如Form_Load）设置
private void Form1_Load(object sender, EventArgs e)
{
    // 设置默认连接数，配合SemaphoreSlim使用
    ServicePointManager.DefaultConnectionLimit = 1000;
    // 关闭Nagle算法，减少延迟（适合高频小请求）
    ServicePointManager.UseNagleAlgorithm = false;
    // 及时释放闲置连接
    ServicePointManager.MaxServicePointIdleTime = 1000;
}

三、关键说明 #

• 资源释放：using语句会自动调用对象的Dispose方法，确保非托管资源（如Socket连接、网络流）被及时回收，从根源上解决内存泄漏问题。
• 并发控制：SemaphoreSlim严格限制同时运行的请求数，避免短时间内创建过多请求导致资源耗尽。
• 异步优化：使用async/await代替手动线程管理，既避免UI线程阻塞，又能更高效地利用系统资源。
• Timer防重叠：_isProcessing标记确保上一次批量请求未完成时，不会触发新的请求，避免请求堆积。

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