.NET7 ASP.NET Core中CPU/IO密集型长时后台任务的正确实现

针对你提到的两类持续运行后台任务，结合.NET官方最佳实践和David Fowler的建议，以下是最简且规范的实现方案，同时对比不同方案的适用性：

核心需求匹配 #

我们需要实现：

• 持续运行的任务逻辑
• 服务器停止时优雅终止任务
• 异常自动重试
• 合理分配线程资源（避免抢占Web请求线程）

1. IO密集型任务（ConcurrentQueue序列化到DB） #

这类任务以异步IO操作为主，应优先使用异步循环+托管服务（BackgroundService），避免阻塞线程池线程，提高资源利用率。

实现代码 #

public class QueueToDbBackgroundService : BackgroundService
{
    private readonly ConcurrentQueue<YourDataModel> _dataQueue;
    private readonly IDbConnection _dbConnection;
    private readonly ILogger<QueueToDbBackgroundService> _logger;

    public QueueToDbBackgroundService(ConcurrentQueue<YourDataModel> dataQueue, IDbConnection dbConnection, ILogger<QueueToDbBackgroundService> logger)
    {
        _dataQueue = dataQueue;
        _dbConnection = dbConnection;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Queue-to-DB service started");

        while (!stoppingToken.IsCancellationRequested)
        {
            try
            {
                if (_dataQueue.TryDequeue(out var dataItem))
                {
                    // 异步序列化+写入数据库，全程用await避免阻塞
                    var serializedData = JsonSerializer.Serialize(dataItem);
                    await _dbConnection.ExecuteAsync(
                        "INSERT INTO YourTable (SerializedData) VALUES (@Data)",
                        new { Data = serializedData },
                        cancellationToken: stoppingToken);
                }
                else
                {
                    // 队列空时短暂等待，避免空循环占用CPU
                    await Task.Delay(100, stoppingToken);
                }
            }
            catch (OperationCanceledException)
            {
                // 收到终止信号，正常退出循环
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "Failed to process queue item");
                // 异常后延迟重试，避免频繁报错
                await Task.Delay(500, stoppingToken);
            }
        }

        _logger.LogInformation("Queue-to-DB service stopped");
    }
}

2. CPU密集型任务（内存对象处理） #

这类任务需要持续占用CPU，应使用独占线程（LongRunning任务）+托管服务，避免抢占线程池中的IO线程（Web请求依赖这些线程）。

实现代码 #

public class MemoryProcessingBackgroundService : BackgroundService
{
    private readonly YourMemoryObjectPool _objectPool;
    private readonly ILogger<MemoryProcessingBackgroundService> _logger;
    private Task _processingTask;

    public MemoryProcessingBackgroundService(YourMemoryObjectPool objectPool, ILogger<MemoryProcessingBackgroundService> logger)
    {
        _objectPool = objectPool;
        _logger = logger;
    }

    protected override Task ExecuteAsync(CancellationToken stoppingToken)
    {
        _logger.LogInformation("Memory processing service started");

        // 用LongRunning创建独占线程，不占用线程池资源
        _processingTask = Task.Factory.StartNew(() =>
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                try
                {
                    if (_objectPool.TryTake(out var memoryObj))
                    {
                        // CPU密集型逻辑：复杂计算、内存对象转换等
                        ProcessMemoryObject(memoryObj);
                        _objectPool.Return(memoryObj);
                    }
                    else
                    {
                        // 无对象时休眠，避免空转
                        Thread.Sleep(100);
                    }
                }
                catch (OperationCanceledException)
                {
                    break;
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "Failed to process memory object");
                    // 异常后延迟重试
                    Thread.Sleep(500);
                }
            }
        }, stoppingToken, TaskCreationOptions.LongRunning, TaskScheduler.Default);

        return _processingTask;
    }

    private void ProcessMemoryObject(YourMemoryObject obj)
    {
        // 示例CPU密集操作：模拟复杂计算
        for (int i = 0; i < 1_000_000; i++)
        {
            obj.CalculatedValue = obj.RawValue * i % 1000;
        }
    }

    public override async Task StopAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Stopping memory processing service");
        // 等待当前处理任务完成后再终止
        if (_processingTask != null)
        {
            await _processingTask;
        }
        await base.StopAsync(cancellationToken);
    }
}

3. 不同方案适用性对比 #

关键注意事项 #

• IO密集型任务必须全程使用异步方法（await），避免阻塞线程池线程。
• CPU密集型任务必须使用LongRunning或独立线程，防止抢占Web请求的线程池资源。
• 异常处理：在任务循环内捕获异常并添加延迟重试，避免频繁报错影响系统稳定性。
• 空循环处理：队列/对象池为空时，添加短暂等待（Task.Delay/Thread.Sleep），避免空转占用CPU。
• 终止信号：将CancellationToken传递到所有可取消的操作中，确保服务器停止时任务能及时终止。

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