5

我有几台计算机使用相同的数据库（SQL Server 2008）

我正在尝试使用数据库在所有这些计算机之间同步任务。

每个任务都由一个锁定 ID 的 guid 表示（如果与 Mutex 相比，那将是 Mutex 名称）

我有一些想法，但我认为它们是一种黑客，并希望这里有人能有更好的解决方案：

  1. 创建一个新表“锁定”每行由一个 guid 组成，在事务中专门锁定表行 - 并在完成后完成/恢复事务。
  2. sp_getapplock在锁定名称为锁定 ID GUID 的事务中使用

我认为保持事务运行不太好......我想也许有一个解决方案不需要我保持打开的事务或会话？

4

3 回答 3

3

我已经整理了一个小班将测试和反馈

public class GlobalMutex
{
    private SqlCommand _sqlCommand;
    private SqlConnection _sqlConnection;

    string sqlCommandText = @"

        declare @result int
        exec @result =sp_getapplock @Resource=@ResourceName, @LockMode='Exclusive', @LockOwner='Transaction', @LockTimeout = @LockTimeout

    ";

    public GlobalMutex(SqlConnection sqlConnection, string unqiueName, TimeSpan lockTimeout)
    {
        _sqlConnection = sqlConnection;
        _sqlCommand = new SqlCommand(sqlCommandText, sqlConnection);
        _sqlCommand.Parameters.AddWithValue("@ResourceName", unqiueName);
        _sqlCommand.Parameters.AddWithValue("@LockTimeout", lockTimeout.TotalMilliseconds);
    }

    private readonly object _lockObject = new object();
    private Locker _lock = null;
    public Locker Lock
    {
        get
        {
            lock(_lockObject)
            {
                if (_lock != null)
                {
                    throw new InvalidOperationException("Unable to call Lock twice"); // dont know why
                }
                _lock = new Locker(_sqlConnection, _sqlCommand);
            }
            return _lock;
        }
    }

    public class Locker : IDisposable
    {
        private SqlTransaction _sqlTransaction;
        private SqlCommand _sqlCommand;

        internal Locker(SqlConnection sqlConnection, SqlCommand sqlCommand)
        {
            _sqlCommand = sqlCommand;
            _sqlTransaction = sqlConnection.BeginTransaction();
            _sqlCommand.Transaction = _sqlTransaction;
            int result = sqlCommand.ExecuteNonQuery();
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing) 
            {
                _sqlTransaction.Commit(); // maybe _sqlTransaction.Rollback() might be slower
            }
        }
    }
}

用法是：

GlobalMutex globalMutex = new GlobalMutex(
    new SqlConnection(""),
    "myGlobalUniqueLockName",
    new TimeSpan(0, 1, 0)
);


using (globalMutex.Lock)
{
    // do work.
}
于 2015-12-03T12:44:56.970 回答
0

我会推荐一些不同的东西：使用队列。与其显式锁定任务，不如将任务添加到处理队列中，让队列处理程序将任务出列并执行工作。额外的解耦也将有助于可扩展性和吞吐量。

于 2012-08-13T14:45:22.130 回答
0

如果您拥有的唯一共享资源是数据库，那么使用事务锁作为解决方案的一部分可能是您的最佳选择。如果我在另一个答案中理解@Remus Rusanu 链接的文章，它还需要在事务中进行出队。

这在一定程度上取决于您计划打开这些锁多长时间。如果你是...

  1. 强制序列化以对相关锁 ID 进行简短操作
  2. 无论如何已经打开事务以完成该操作

...那么您的选项 2 可能是最简单和最可靠的。几年来，我在生产系统中都有类似的解决方案，没有任何问题。如果您将互斥锁的创建与事务的创建捆绑在一起并将其全部包装在“使用”块中，则会变得更加容易。

using (var transaction = MyTransactionUtil.CreateTransaction(mutexName))
{
    // do stuff
    transaction.Commit();
}

在您的 CreateTransaction 实用程序方法中，您在创建事务后立即调用 sp_getapplock。然后整个事情（包括互斥锁）一起提交或回滚。

于 2012-09-12T18:29:11.800 回答