ASP.NET Core中IHostedService之间的同步实现方案咨询

针对你的需求——让TimerBasedService的首次执行等待StartupService完成初始化，以下是具体实现方案，同时解答你的同步对象疑问：

关于lock和ManualResetEvent的适用性 #

• lock不适用：lock的作用是保护临界区资源，防止多线程并发访问，无法实现"等待某个操作完成"的场景。如果强行用lock实现等待，会导致线程阻塞甚至死锁，完全不符合你的需求。
• ManualResetEvent（或ManualResetEventSlim）可行：这类等待句柄可以实现线程间的信号通知，让TimerBasedService等待StartupService发出"初始化完成"的信号后再执行首次操作。不过更推荐使用贴合.NET异步模型的TaskCompletionSource，代码更简洁安全。

方案一：使用ManualResetEventSlim（轻量等待句柄） #

1. 注册全局同步对象 #

在Program.cs中注册一个单例的ManualResetEventSlim，初始状态为未触发：

builder.Services.AddSingleton<ManualResetEventSlim>(sp => new ManualResetEventSlim(false));

2. 实现StartupService #

在初始化完成后触发信号：

public class StartupService : IHostedService
{
    private readonly ManualResetEventSlim _startupCompletedEvent;

    public StartupService(ManualResetEventSlim startupCompletedEvent)
    {
        _startupCompletedEvent = startupCompletedEvent;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        // 执行你的启动初始化逻辑（比如加载配置、预热缓存）
        await PerformStartupTasks(cancellationToken);
        
        // 标记初始化完成，释放等待的Timer服务
        _startupCompletedEvent.Set();
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _startupCompletedEvent.Dispose();
        return Task.CompletedTask;
    }

    private async Task PerformStartupTasks(CancellationToken cancellationToken)
    {
        // 模拟耗时初始化操作
        await Task.Delay(3000, cancellationToken);
    }
}

3. 实现TimerBasedService #

等待信号触发后执行首次操作，再启动定期任务：

public class TimerBasedService : IHostedService, IDisposable
{
    private readonly ManualResetEventSlim _startupCompletedEvent;
    private Timer? _timer;
    private readonly ILogger<TimerBasedService> _logger;

    public TimerBasedService(ManualResetEventSlim startupCompletedEvent, ILogger<TimerBasedService> logger)
    {
        _startupCompletedEvent = startupCompletedEvent;
        _logger = logger;
    }

    public Task StartAsync(CancellationToken cancellationToken)
    {
        // 异步等待启动完成，避免阻塞服务启动流程
        _ = WaitForStartupThenRunFirstTask(cancellationToken);
        
        // 初始设置定时器为无限延迟，等首次执行后再调整周期
        _timer = new Timer(RunPeriodicTask, null, Timeout.Infinite, TimeSpan.FromMinutes(5));

        return Task.CompletedTask;
    }

    private async Task WaitForStartupThenRunFirstTask(CancellationToken cancellationToken)
    {
        try
        {
            // 等待初始化完成，同时响应服务取消信号
            _startupCompletedEvent.Wait(cancellationToken);
            
            // 执行首次操作
            await RunPeriodicTaskAsync(cancellationToken);
            
            // 首次执行完成后，启动定期任务
            _timer?.Change(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
        }
        catch (OperationCanceledException)
        {
            // 服务被取消，无需额外处理
        }
    }

    private void RunPeriodicTask(object? state)
    {
        // 包装为异步方法，避免阻塞线程池线程
        _ = RunPeriodicTaskAsync(CancellationToken.None);
    }

    private async Task RunPeriodicTaskAsync(CancellationToken cancellationToken)
    {
        _logger.LogInformation("Timer service executing task at {Time}", DateTimeOffset.Now);
        // 你的定期执行逻辑
        await Task.Delay(1000, cancellationToken);
    }

    public void Dispose()
    {
        _timer?.Dispose();
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        _timer?.Change(Timeout.Infinite, Timeout.Infinite);
        return Task.CompletedTask;
    }
}

4. 注册后台服务 #

builder.Services.AddHostedService<StartupService>();
builder.Services.AddHostedService<TimerBasedService>();

方案二：使用TaskCompletionSource（推荐，适配异步模型） #

这种方式不需要处理原生等待句柄，完全基于.NET异步任务模型，代码更简洁：

1. 注册TaskCompletionSource #

builder.Services.AddSingleton<TaskCompletionSource<bool>>(sp => new TaskCompletionSource<bool>());

2. 修改StartupService #

初始化完成后设置任务结果：

public class StartupService : IHostedService
{
    private readonly TaskCompletionSource<bool> _startupCompletedTcs;

    public StartupService(TaskCompletionSource<bool> startupCompletedTcs)
    {
        _startupCompletedTcs = startupCompletedTcs;
    }

    public async Task StartAsync(CancellationToken cancellationToken)
    {
        await PerformStartupTasks(cancellationToken);
        // 标记初始化完成
        _startupCompletedTcs.TrySetResult(true);
    }

    // StopAsync和PerformStartupTasks方法同方案一
}

3. 修改TimerBasedService的等待逻辑 #

private async Task WaitForStartupThenRunFirstTask(CancellationToken cancellationToken)
{
    try
    {
        // 等待初始化任务完成，响应取消信号
        await _startupCompletedTcs.Task.WaitAsync(cancellationToken);
        
        await RunPeriodicTaskAsync(cancellationToken);
        _timer?.Change(TimeSpan.FromMinutes(5), TimeSpan.FromMinutes(5));
    }
    catch (OperationCanceledException)
    {
    }
}

其他代码和方案一一致。

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