插入语句/存储过程死锁

Question

我有一个使用 linq 死锁的插入语句。所以我把它放在一个存储过程中，以防周围的语句影响它。

现在存储过程是死锁的。根据 Server Profiler，插入语句的某些内容正在锁定自身。它声称其中两个插入语句正在等待释放 PK 索引：

当我将代码放在存储过程中时，它现在声明此存储过程已与此存储过程的另一个实例死锁。

这里是代码。 select 语句类似于 linq 在执行自己的查询时使用的语句。我只是想看看该项目是否存在，如果不存在则插入它。我可以通过 PK 或一些查找值找到系统。

       SET NOCOUNT ON;
       BEGIN TRY
        SET TRANSACTION ISOLATION LEVEL SERIALIZABLE

        BEGIN TRANSACTION SPFindContractMachine
        DECLARE @id int;
        set @id = (select [m].pkID from Machines as [m]
                        WHERE ([m].[fkContract] = @fkContract) AND ((
                        (CASE 
                            WHEN @bByID = 1 THEN 
                                (CASE 
                                    WHEN [m].[pkID] = @nMachineID THEN 1
                                    WHEN NOT ([m].[pkID] = @nMachineID) THEN 0
                                    ELSE NULL
                                 END)
                            ELSE 
                                (CASE 
                                    WHEN ([m].[iA_Metric] = @lA) AND ([m].[iB_Metric] = @lB) AND ([m].[iC_Metric] = @lC) THEN 1
                                    WHEN NOT (([m].[iA_Metric] = @lA) AND ([m].[iB_Metric] = @lB) AND ([m].[iC_Metric] = @lC)) THEN 0
                                    ELSE NULL
                                 END)
                         END)) = 1));
        if (@id IS NULL)
        begin
            Insert into Machines(fkContract, iA_Metric, iB_Metric, iC_Metric, dteFirstAdded) 
                values (@fkContract, @lA, @lB, @lC, GETDATE());

            set @id = SCOPE_IDENTITY();
        end

        COMMIT TRANSACTION SPFindContractMachine

        return @id;

    END TRY
    BEGIN CATCH
        if @@TRANCOUNT > 0
            ROLLBACK TRANSACTION SPFindContractMachine
    END CATCH

Answer 1

任何遵循模式的过程：

BEGIN TRAN
check if row exists with SELECT
if row doesn't exist INSERT
COMMIT

在生产中会遇到麻烦，因为没有什么可以阻止两个胎面同时进行检查并且都得出应该插入的结论。特别是，在序列化隔离级别（如您的情况）下，此模式保证死锁。

更好的模式是使用数据库唯一约束并始终插入，捕获重复的键违规错误。这也显着提高了性能。

另一种选择是使用MERGE 语句：

create procedure usp_getOrCreateByMachineID
    @nMachineId int output,
    @fkContract int,
    @lA int,
    @lB int,
    @lC int,
    @id int output
as
begin
    declare @idTable table (id int not null);
    merge Machines as target
        using (values (@nMachineID, @fkContract, @lA, @lB, @lC, GETDATE()))
            as source (MachineID, ContractID, lA, lB, lC, dteFirstAdded)
    on (source.MachineID = target.MachineID)
    when matched then
        update set @id = target.MachineID
    when not matched then
        insert (ContractID, iA_Metric, iB_Metric, iC_Metric, dteFirstAdded)
        values (source.contractID, source.lA, source.lB, source.lC, source.dteFirstAdded)
    output inserted.MachineID into @idTable;
    select @id = id from @idTable;
end 
go

create procedure usp_getOrCreateByMetrics
    @nMachineId int output,
    @fkContract int,
    @lA int,
    @lB int,
    @lC int,
    @id int output
as
begin
    declare @idTable table (id int not null);
    merge Machines as target
        using (values (@nMachineID, @fkContract, @lA, @lB, @lC, GETDATE()))
            as source (MachineID, ContractID, lA, lB, lC, dteFirstAdded)
    on (target.iA_Metric = source.lA
        and target.iB_Metric = source.lB
        and target.iC_Metric = source.lC)
    when matched then
        update set @id = target.MachineID
    when not matched then
        insert (ContractID, iA_Metric, iB_Metric, iC_Metric, dteFirstAdded)
        values (source.contractID, source.lA, source.lB, source.lC, source.dteFirstAdded)
    output inserted.MachineID into @idTable;
    select @id = id from @idTable;
end 
go

此示例将这两种情况分开，因为 T-SQL 查询应该从不尝试在一个查询中解析两种不同的解决方案（结果永远不可优化）。由于手头的两个任务（通过机器 ID 获取和通过度量获取）是完全独立的，因此应该是单独的过程，调用者应该调用适当的过程，而不是传递标志。这个例子展示了如何使用 MERGE 实现（可能）期望的结果，但是当然，正确和最佳解决方案取决于实际的模式（表定义、索引和 cosntraints到位）和实际要求（不清楚如果标准已经匹配，而不是输出和@id，该程序应该做什么？）。

通过消除 SERIALIZABLE 隔离，这不再保证死锁，但它仍然可能死锁。当然，解决死锁完全取决于未指定的模式，因此在这种情况下实际上无法提供死锁的解决方案。有一个锁定所有候选行的大锤（强制 UPDLOCK 甚至 TABLOCX），但是这样的解决方案会在大量使用时扼杀吞吐量，所以我不建议在不知道用例的情况下使用它。

Answer 2

摆脱交易。它并没有真正帮助你，而是在伤害你。这应该可以解决您的问题。

Answer 3

这个 SQL 怎么样？它将现有数据的检查和插入移动到单个语句中。这样，当两个线程正在运行时，它们不会因为等待对方而死锁。充其量，线程二死锁等待线程一，但一旦线程一完成，线程二就可以运行。

BEGIN TRY

  BEGIN TRAN SPFindContractMachine

  INSERT INTO Machines (fkContract, iA_Metric, iB_Metric, iC_Metric, dteFirstAdded)
    SELECT @fkContract, @lA, @lB, @lC, GETDATE()
      WHERE NOT EXISTS (
        SELECT * FROM Machines
        WHERE fkContract = @fkContract
        AND ((@bByID = 1 AND pkID = @nMachineID)
             OR
             (@bByID <> 1 AND iA_Metric = @lA AND iB_Metric = @lB AND iC_Metric = @lC))

  DECLARE @id INT

  SET @id = (
    SELECT pkID FROM Machines
    WHERE fkContract = @fkContract
    AND ((@bByID = 1 AND pkID = @nMachineID)
         OR
         (@bByID <> 1 AND iA_Metric = @lA AND iB_Metric = @lB AND iC_Metric = @lC)))

  COMMIT TRAN SPFindContractMachine

  RETURN @id

END TRY
BEGIN CATCH
  IF @@TRANCOUNT > 0
    ROLLBACK TRAN SPFindContractMachine
END CATCH

我还将这些 CASE 语句更改为 ORed 子句，只是因为它们对我来说更容易阅读。如果我回想一下我的 SQL 理论，ORing 可能会使这个查询慢一点。

Answer 4

我想知道在早期的 SELECT(s) 中添加一个 UPDLOCK 提示是否可以解决这个问题；它应该避免出现死锁情况，即阻止另一个 spud 对您将要变异的数据进行读锁。