锁定表以在 LINQ 中获取 MAX

Question

我在 LINQ 中有一个查询，我想获取表的最大代码并增加它并使用新代码插入新记录。就像 SQL Server 的 IDENTITY 功能一样，但这里我的 Code 列是 char(5)，其中可以是字母和数字。

我的问题是，当插入新行时，两个并发进程获得最大值并向记录插入相等的代码。

我的命令是：

var maxCode = db.Customers.Select(c=>c.Code).Max();
var anotherCustomer = db.Customers.Where(...).SingleOrDefault();
anotherCustomer.Code = GenerateNextCode(maxCode);
db.SubmitChanges();

我跨 1000 个线程运行此命令，每个线程更新 200 个客户，并使用具有 IsolationLevel.Serialized 的事务，在执行两到三次后发生错误：

using (var db = new DBModelDataContext())
{
    DbTransaction tran = null;
    try
    {
        db.Connection.Open();
        tran = db.Connection.BeginTransaction(IsolationLevel.Serializable);
        db.Transaction = tran;
        .
        .
        .
        .
        tran.Commit();
    }
    catch
    {
        tran.Rollback();
    }
    finally
    {
        db.Connection.Close();
    }
}

错误：

事务（进程 ID 60）是 锁资源死锁 另一个过程并被选为 僵局受害者。重新运行 交易。

其他 IsolationLevel 会生成此错误：

未找到或更改行。

请帮助我，谢谢。

UPDATE2：我有一个生成新代码的.NET 方法，该代码是字母数字的。 UPDATE3：我的.NET函数生成如下代码： 0000, 0001, 0002, ... , 0009, 000a, 000b, 000c, ... , 000z, 0010, 0011, 0012, ... , 0019, 001a, 001b 、001z、……

Answer 1

避免锁定和连续访问相同的“慢速访问”资源：

• 在开始时，您的应用程序（服务）计算下一个 id（例如，max + 1）
• 在某些变量中（您应该仅锁定对此变量的访问）保留，例如100 个值（这取决于您的 id 的使用情况）
• 使用这些 id

避免使用 IDENTITY 列（如果事务回滚，id 仍将递增）

使用某个表来存储每个表（或所有表）的键（最后一个或下一个 id）变体）。

运气。

对于您的 Web 应用程序：

如何更改和访问应用程序状态：

Application.Lock();
Application["IDS"] = <some ids>
Application.UnLock();

第二种解决方案：

使用存储过程和代码，如下所示：

declare @id int

update t set
    @id = id
    ,id = @id + 1 
from dbo.TableIdGenerator t where t.TableName = 'my table name that id I need'

select @id

更新操作是原子的，您可以增加 id 并返回当前的 id。
不要忘记为每个表的 ID 插入第一条也是唯一一条记录。

第三种解决方案：

使用CLR函数。

Answer 2

如果可能的话，尝试重新考虑您的数据库设计。正如您已经注意到的，在锁定整个表时必须使用隔离级别 Serialized 可能会很麻烦。

我假设 5 个字符的唯一递增值是必需的，因为如果不是这样，您绝对应该简单地使用 IDENTITY 列。然而，假设情况并非如此，这里有一个可能可行的想法。

尝试创建一个方法，允许将 5 个字符的标识符表示为数字。如何执行此操作取决于 char 标识符中允许使用哪些字符以及可能的组合，但这里有一些示例： '00000' -> 0, '00009', ->; 9、'0000z'-> 36、'00010'-> 37、'0001z'-> 71、'zzzzz'-> 60466175. 找到方法后，请对表使用递增主键，并使用在插入记录后计算字符标识符的触发器。当触发器不合适时，您也可以在 .NET 中执行此操作。或者您可以选择不在数据库中存储该 5 个字符的值，因为它是经过计算的。您可以将其定义在视图中或简单地定义为域实体中的属性。

Answer 3

我有一个解决方案，但不完整，它减少了错误和问题：我有一个名为：“lock.txt”的文件，每次尝试获取锁定都应打开此文件，获取最大代码并生成下一个并更新我的表并关闭文件。该文件只是用于打开和关闭，里面没有任何内容。

public void DoTheJob()
{
int tries = 0;
    try
    {
        using (var sr = new StreamReader(@"c:\lock.txt"))
        {
            try
            {
                // get the maximum code from my table
                // generate next code
                // update current record with the new code
            }
            catch (Exception ex)
            {
                Logger.WriteError(ex);
            }
            finally
            {
                sr.Close();
            }
        }
    }
    catch
    {
        Thread.Sleep(2000); // wait for lock for 2 second
    tries++;
    if (tries > 15)
        throw new Exception("Timeout, try again.");
    }
}

请说明这个解决方案是否正确。
或者使用 StreamWriter。

Answer 4

查看您的函数GenerateNextCode 非常有用，因为它可能是至关重要的信息。为什么？因为我不相信不可能将此功能从 更改

f(code) -> code

为

f(id) -> code

如果后者为真，您可以重新设计您的表，整个概念会容易得多。

但假设这确实不可能，有一些快速的解决方案——使用带有预生成代码的台球表。然后在主表中使用简单的 ids（自动增量）。
缺点：您必须使用额外的联接来检索数据。我个人不喜欢它。

另一种解决方案，“正常”解决方案：保持较低的隔离级别并简单地处理异常（即再次获取代码，再次计算新代码并保存数据）。这是非常经典的情况，有网络，没有网络，都没关系。

请注意：并发编辑相同数据时您会遇到相同的问题。所以从某种意义上来说，你无法避免这种问题。

编辑：

所以，我猜对了，这个函数只是 f(id) ->代码。您可以删除代码列并使用自动增量 id。然后添加一个视图，在其中动态计算代码。使用视图作为从表中检索数据的方式始终是一个好主意（将其视为 C# 中属性的 getter）。
如果您担心 CPU 使用率；-) 您可以在插入记录时计算代码（使用触发器）。

当然，锁定记录的问题并没有完全消除（仍然可能发生并发编辑）。

Answer 5

这是我的答案，不完全正确，但没有错误。

public static void WaitLock<T>() where T : class
{
    using (var db = GetDataContext())
    {
        var tableName = typeof(T).Name;
        var count = 0;
        while (true)
        {
            var recordsUpdated = db.ExecuteCommand("UPDATE LockedTable SET IsLocked = 1 WHERE TableName = '" + tableName + "' AND IsLocked = 0");
            if (recordsUpdated <= 0)
            {
                Thread.Sleep(2000);
                count++;
                if (count > 50)
                    throw new Exception("Timeout getting lock on table: " + tableName);
            }
            else
            {
                break;
            }
        }
    }
}


public static void ReleaseLock<T>() where T : class
{
    using (var db = GetDataContext())
    {
        var tableName = typeof(T).Name;
        db.ExecuteCommand("UPDATE LockedTable SET IsLocked = 0 WHERE TableName = '" + tableName + "' AND IsLocked = 1");
    }
}
public static void GetContactCode(int id)
{
    int tries = 0;
    try
    {
        WaitLock<Contact>();
        using (var db = GetDataContext())
        {
            try
            {
                var ct = // get contact
                var maxCode = // maximum code
                ct.Code = // generate next
                db.SubmitChanges();
            }
            catch
            {
            }
        }
    }
    catch
    {
        Thread.Sleep(2000);
        tries++;
        if (tries > 15)
            throw new Exception("Timeout, try again.");
    }
    finally
    {
        ReleaseLock<Contact>();
    }
}