ASP.NET多用户同时预约同一时段的数据库插入冲突解决方案求助

嘿，这个并发预约冲突的问题在多用户服务系统里太常见了，我给你几个经过实战验证的解决办法，适配你的ASP.NET+SQL Server场景，保证同一时段只有一个用户能预约成功：

方案1：数据库存储过程加排他锁（最可靠的核心方案） #

这是最推荐的方式，直接在数据库层面通过事务和锁机制保证原子性，从根源上阻止并发冲突。你可以修改你的存储过程，在检查时段是否可用时加上UPDLOCK, HOLDLOCK提示，确保同一时间只有一个事务能执行检查和插入操作。

示例存储过程代码：

CREATE PROCEDURE BookAppointment
    @UserId INT,
    @ServiceId INT,
    @SlotStartTime DATETIME,
    @SlotEndTime DATETIME
AS
BEGIN
    SET NOCOUNT ON;
    BEGIN TRANSACTION;

    -- 用UPDLOCK+HOLDLOCK锁定查询范围，防止其他事务读取或修改
    IF NOT EXISTS (
        SELECT 1 FROM Appointments 
        WHERE ServiceId = @ServiceId 
        AND (SlotStartTime < @SlotEndTime AND SlotEndTime > @SlotStartTime)
        WITH (UPDLOCK, HOLDLOCK)
    )
    BEGIN
        -- 时段未被占用，执行插入
        INSERT INTO Appointments (UserId, ServiceId, SlotStartTime, SlotEndTime)
        VALUES (@UserId, @ServiceId, @SlotStartTime, @SlotEndTime);
        COMMIT TRANSACTION;
        SELECT 1 AS AppointmentResult; -- 返回1表示预约成功
    END
    ELSE
    BEGIN
        -- 时段已被占用，回滚事务
        ROLLBACK TRANSACTION;
        SELECT 0 AS AppointmentResult; -- 返回0表示预约失败
    END
END

原理说明 #

• UPDLOCK：给查询到的行（或查询范围）加上更新锁，其他事务只能读不能修改，直到当前事务结束
• HOLDLOCK：将锁的持有时间延长到整个事务周期，避免其他事务在检查和插入的间隙抢占时段
• 整个逻辑包裹在事务中，确保检查和插入是原子操作，不会出现“检查时可用，插入时已被占用”的中间状态

在ASP.NET代码里，你只需要调用这个存储过程，根据返回的AppointmentResult值给用户返回对应的提示（成功/时段已被占用）即可。

方案2：利用数据库唯一约束（适合固定时长的时段） #

如果你的服务时段是固定长度的（比如每个时段30分钟），可以把每个时段抽象成一个独立的TimeSlot实体，然后给Appointments表添加唯一约束，确保同一个服务的同一个时段只能被预约一次。

步骤： #

1. 先创建TimeSlots表存储所有可用时段：

CREATE TABLE TimeSlots (
    TimeSlotId INT PRIMARY KEY IDENTITY,
    SlotStartTime DATETIME NOT NULL,
    SlotEndTime DATETIME NOT NULL,
    ServiceId INT NOT NULL
);

2. 给Appointments表添加唯一约束：

ALTER TABLE Appointments
ADD CONSTRAINT UQ_Appointments_ServiceId_TimeSlotId UNIQUE (ServiceId, TimeSlotId);

3. 修改存储过程，插入时关联对应的TimeSlotId，如果违反唯一约束就返回失败：

CREATE PROCEDURE BookFixedSlotAppointment
    @UserId INT,
    @TimeSlotId INT
AS
BEGIN
    SET NOCOUNT ON;
    BEGIN TRY
        INSERT INTO Appointments (UserId, TimeSlotId)
        VALUES (@UserId, @TimeSlotId);
        SELECT 1 AS AppointmentResult;
    END TRY
    BEGIN CATCH
        -- 捕获唯一约束冲突错误（错误号2627）
        IF ERROR_NUMBER() = 2627
        BEGIN
            SELECT 0 AS AppointmentResult;
        END
        ELSE
        BEGIN
            -- 处理其他错误
            THROW;
        END
    END CATCH
END

这种方式实现简单，数据库会自动帮你拦截重复预约，不需要手动处理锁逻辑，适合时段规则固定的场景。

方案3：应用层分布式锁（适合多服务器部署场景） #

如果你的ASP.NET应用是多实例部署的，或者需要在应用层做更灵活的并发控制，可以用分布式锁（比如Redis锁）来实现。在用户发起预约请求时，先尝试获取对应时段的锁，只有拿到锁的请求才能执行数据库操作。

示例ASP.NET代码（用StackExchange.Redis）：

using StackExchange.Redis;

public async Task<IActionResult> SaveAppointment(AppointmentRequest request)
{
    // 初始化Redis连接
    var redis = ConnectionMultiplexer.Connect("your-redis-connection-string");
    var db = redis.GetDatabase();
    
    // 生成唯一的锁键，标识当前服务的当前时段
    var lockKey = $"AppointmentLock:{request.ServiceId}:{request.SlotStartTime:yyyyMMddHHmm}:{request.SlotEndTime:yyyyMMddHHmm}";
    
    // 尝试获取锁：超时时间10秒，锁持有时间5秒（足够完成数据库操作）
    var lockAcquired = await db.LockTakeAsync(lockKey, Environment.MachineName, TimeSpan.FromSeconds(5));
    
    if (!lockAcquired)
    {
        // 没拿到锁，返回冲突提示
        return BadRequest("当前时段正在被其他用户预约，请稍后再试");
    }
    
    try
    {
        // 调用存储过程执行预约
        var result = await _dbContext.Database.ExecuteSqlRawAsync(
            "EXEC BookAppointment @UserId, @ServiceId, @SlotStartTime, @SlotEndTime",
            request.UserId, request.ServiceId, request.SlotStartTime, request.SlotEndTime);
            
        return result == 1 ? Ok("预约成功") : BadRequest("时段已被占用");
    }
    finally
    {
        // 无论成功失败，都释放锁
        await db.LockReleaseAsync(lockKey, Environment.MachineName);
    }
}

这种方式可以在应用层拦截大部分并发请求，减轻数据库的压力，适合高并发场景。

额外注意事项 #

• 一定要给用户返回清晰的提示，比如“时段已被占用”或“当前预约人数过多，请稍后再试”，提升用户体验
• 测试并发场景时，可以用多个浏览器窗口同时点击，或者用JMeter等工具模拟多用户请求，验证方案的有效性
• 如果用数据库锁方案，要注意锁的粒度，避免锁定整个表影响性能，尽量只锁定需要检查的行范围

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