多实例Blazor应用后台任务重复执行问题求解

针对你的多实例Blazor应用后台任务重复执行的问题，直接给你一套基于数据库的分布式锁+临时Leader方案，完全满足你的核心诉求：任务顺序执行、支持多实例运行、任意实例可触发、实例宕机自动释放锁。

核心思路 #

利用数据库的原子事务实现带过期时间的分布式锁，每次任务触发时，只有成功获取锁的实例才会执行任务；锁默认有效期2分钟，避免实例宕机导致锁永久占用；任意实例都可以尝试获取锁，没有固定Leader，完美适配Azure实例频繁启停的场景。

具体实现步骤 #

1. 创建数据库锁表 #

先在你的数据库里建一张专门的锁表，用来记录各任务类型的锁状态：

CREATE TABLE BackgroundTaskLocks (
    TaskType VARCHAR(50) PRIMARY KEY, -- 任务类型：比如SendEmail、SyncExternalService、MarkExpiredEvents
    LockOwnerInstanceId VARCHAR(100), -- 持有锁的实例ID（Azure的WEBSITE_INSTANCE_ID）
    LockExpiresAt DATETIME2, -- 锁过期时间（UTC）
    LastHeartbeatAt DATETIME2 -- 心跳时间（可选，用于长任务续期）
);

2. 获取实例唯一ID #

每个Azure App Service实例都有唯一的WEBSITE_INSTANCE_ID环境变量，直接拿来用：

var instanceId = Environment.GetEnvironmentVariable("WEBSITE_INSTANCE_ID") ?? Guid.NewGuid().ToString();

（本地调试时用Guid兜底，避免环境变量不存在）

3. 锁获取与任务执行逻辑 #

每次触发任务（定时或手动）时，先执行原子锁获取操作，只有拿到锁才执行任务：

public async Task TriggerSendEmailTaskAsync()
{
    var taskType = "SendEmail";
    var lockExpiry = DateTime.UtcNow.AddMinutes(2); // 锁有效期设为2分钟，比任务最长执行时间长即可
    using var tx = await _dbContext.Database.BeginTransactionAsync();

    try
    {
        // 查询当前任务的锁状态
        var taskLock = await _dbContext.BackgroundTaskLocks
            .FirstOrDefaultAsync(l => l.TaskType == taskType);

        bool lockAcquired = false;
        if (taskLock == null)
        {
            // 锁不存在，直接创建并持有
            _dbContext.BackgroundTaskLocks.Add(new BackgroundTaskLock
            {
                TaskType = taskType,
                LockOwnerInstanceId = instanceId,
                LockExpiresAt = lockExpiry,
                LastHeartbeatAt = DateTime.UtcNow
            });
            lockAcquired = true;
        }
        else if (taskLock.LockExpiresAt < DateTime.UtcNow || taskLock.LockOwnerInstanceId == instanceId)
        {
            // 锁已过期，或者是当前实例持有的锁，更新有效期
            taskLock.LockOwnerInstanceId = instanceId;
            taskLock.LockExpiresAt = lockExpiry;
            taskLock.LastHeartbeatAt = DateTime.UtcNow;
            lockAcquired = true;
        }
        // 否则锁被其他有效实例持有，直接退出

        if (lockAcquired)
        {
            await _dbContext.SaveChangesAsync();
            await tx.CommitAsync();

            // 执行任务逻辑
            await ExecuteSendEmailTaskAsync();

            // 任务完成后主动释放锁（可选，让其他实例可以立即触发）
            var completedLock = await _dbContext.BackgroundTaskLocks.FirstAsync(l => l.TaskType == taskType);
            completedLock.LockExpiresAt = DateTime.UtcNow;
            await _dbContext.SaveChangesAsync();
        }
        else
        {
            await tx.RollbackAsync();
            // 可以返回提示："已有实例在执行该任务"
            return;
        }
    }
    catch
    {
        await tx.RollbackAsync();
        throw;
    }
}

4. 长任务续期（可选） #

如果你的任务执行时间可能超过2分钟，可以在任务执行过程中定期更新锁的过期时间：

// 在任务执行的循环中添加心跳
while (taskIsRunning)
{
    // 执行部分任务逻辑...
    
    // 每30秒更新一次锁有效期
    var taskLock = await _dbContext.BackgroundTaskLocks.FirstAsync(l => l.TaskType == "SendEmail");
    if (taskLock.LockOwnerInstanceId == instanceId)
    {
        taskLock.LockExpiresAt = DateTime.UtcNow.AddMinutes(2);
        taskLock.LastHeartbeatAt = DateTime.UtcNow;
        await _dbContext.SaveChangesAsync();
    }
    await Task.Delay(30000);
}

适配你的补充需求 #

• 临时Leader选举：每次任务触发时，能获取锁的实例就是临时Leader，没有永久绑定；任意实例都可以触发任务并尝试成为Leader，完全符合你的要求。
• 顺序执行：锁机制保证同一时间只有一个实例执行任务，自然满足任务顺序处理的需求。
• 实例宕机处理：锁有2分钟过期时间，实例宕机后锁到期，其他实例可以正常获取锁执行任务，不会出现锁永久占用的情况。

为什么不选其他方案 #

• 消息队列：你提到会增加复杂度和重试逻辑，这个方案基于现有数据库，不需要额外组件，直接复用现有架构。
• Azure Function：单点故障问题无法避免，多区域部署又回到多实例重复执行的问题，不如直接在现有App Service实例中处理。

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