.NET Core BackgroundService多不同周期定时任务实现及异常排查

问题根源 #

你当前的代码只有FirstLoop能执行，是因为ExecuteAsync方法里是顺序执行异步循环：第一个while循环会一直阻塞（直到服务停止），后续的定时器初始化和循环代码永远不会被执行到。

修复现有代码的方案 #

将每个定时任务的逻辑封装为独立的异步方法，然后通过Task.WhenAll并行启动所有任务，让它们同时运行。

步骤1：封装通用定时执行逻辑 #

避免重复代码，创建一个通用方法处理定时任务的循环、异常和配置读取：

private async Task RunPeriodicTaskAsync(Func<Task> workFunc, string configKey, string taskName, CancellationToken stoppingToken)
{
    if (!double.TryParse(_configuration[configKey], out double intervalSeconds))
    {
        _logger.LogError($"缺少 {taskName} 配置项");
        return;
    }

    using var timer = new PeriodicTimer(TimeSpan.FromSeconds(intervalSeconds));
    while (!stoppingToken.IsCancellationRequested && await timer.WaitForNextTickAsync(stoppingToken))
    {
        try
        {
            await workFunc();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "{TaskName} 执行出错", taskName);
        }
    }
}

步骤2：并行启动所有任务 #

修改ExecuteAsync方法，用Task.WhenAll同时启动所有定时任务：

protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
    var tasks = new List<Task>
    {
        RunPeriodicTaskAsync(DoFirstWorkAsync, "FirstLoop", "FirstLoop", stoppingToken),
        RunPeriodicTaskAsync(DoSecondWorkAsync, "SecondLoop", "SecondLoop", stoppingToken),
        RunPeriodicTaskAsync(DoThirdWorkAsync, "ThirdLoop", "ThirdLoop", stoppingToken),
        RunPeriodicTaskAsync(DoForthWorkAsync, "ForthLoop", "ForthLoop", stoppingToken)
    };

    await Task.WhenAll(tasks);
}

当前.NET的新实现方案（.NET 6+） #

方案1：每个任务独立为BackgroundService #

将每个定时任务封装成单独的BackgroundService子类，由宿主独立管理生命周期，解耦性更强，单个任务的异常不会直接影响其他任务。

示例（以FirstLoop为例）：

public class FirstLoopService : BackgroundService
{
    private readonly IConfiguration _configuration;
    private readonly ILogger<FirstLoopService> _logger;

    public FirstLoopService(IConfiguration configuration, ILogger<FirstLoopService> logger)
    {
        _configuration = configuration;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        if (!double.TryParse(_configuration["FirstLoop"], out double intervalSeconds))
        {
            _logger.LogError("缺少 FirstLoop 配置项");
            return;
        }

        using var timer = new PeriodicTimer(TimeSpan.FromSeconds(intervalSeconds));
        while (!stoppingToken.IsCancellationRequested && await timer.WaitForNextTickAsync(stoppingToken))
        {
            try
            {
                await DoFirstWorkAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, "FirstLoop 执行出错");
            }
        }
    }

    private Task DoFirstWorkAsync()
    {
        // 你的业务逻辑
        return Task.CompletedTask;
    }
}

然后在Program.cs中注册所有服务：

builder.Services.AddHostedService<FirstLoopService>();
builder.Services.AddHostedService<SecondLoopService>();
builder.Services.AddHostedService<ThirdLoopService>();
builder.Services.AddHostedService<ForthLoopService>();

方案2：使用Cron表达式调度（可选） #

如果需要更灵活的调度规则（如特定时间执行），可以使用.NET生态的第三方库（如Quartz.NET、Hangfire），但对于固定周期的任务，原生PeriodicTimer已经足够轻量高效。

注意事项 #

• 确保配置项的数值正确：比如每分钟对应60秒，每小时对应3600秒，每天对应86400秒。
• 异常处理必须覆盖每个任务的执行逻辑，避免单个任务崩溃导致整个服务停止。
• 所有任务都要监听stoppingToken，确保服务停止时能优雅退出。

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