C#：能否检测当前执行上下文是否在`lock(this)`内？

Question

如果我想强制从锁内访问一个对象，如下所示：

var obj = new MyObject();

lock (obj)
{
    obj.Date = DateTime.Now;
    obj.Name = "My Name";
}

是否可以从 AddOne 和 RemoveOne 函数内检测是否当前执行上下文在锁内？

类似于：

Monitor.AreWeCurrentlyEnteredInto(this)

---

编辑：（为了澄清意图）

这里的意图是能够拒绝在锁之外进行的任何修改，以便对对象本身的所有更改都将是事务性和线程安全的。锁定对象本身内的互斥体并不能确保编辑的事务性质。

---

我知道可以这样做：

var obj = new MyObject();

obj.MonitorEnterThis();

try
{
    obj.Date = DateTime.Now;
    obj.Name = "My Name";
}
finally
{
    obj.MonitorExitThis();
}

但这将允许任何其他线程调用添加/删除函数，而无需先调用Enter，从而绕过保护。

---

编辑2：

这是我目前正在做的事情：

var obj = new MyObject();

using (var mylock = obj.Lock())
{
    obj.SetDate(DateTime.Now, mylock);
    obj.SetName("New Name", mylock);
}

这很简单，但有两个问题：

1. 我正在实现 IDisposable mylock对象，有点 滥用 IDisposable 接口。

2. 我想将 SetDate 和 SetName 函数更改为 为清楚起见，属性。

Answer 1

我认为如果不自己跟踪状态（例如通过使用某种信号量），这是不可能的。但即使是这样，这也会严重违反封装性。您的方法通常不应该关心它们是否在特定的锁定上下文中执行。

Answer 2

没有记录在案的方法来在运行时检查这种情况，如果有的话，我会对使用它的任何代码表示怀疑，因为任何基于调用堆栈改变其行为的代码都将很难调试。

真正的 ACID 语义实现起来并不简单，我个人也不会尝试；这就是我们数据库的用途，如果您需要代码快速/可移植，您可以使用内存数据库。如果您只想要强制单线程语义，那么这是一个更容易驯服的野兽，尽管作为免责声明，我应该提到，从长远来看，您最好简单地提供原子操作，而不是试图阻止多线程操作。线程访问。

假设您有充分的理由想要这样做。这是一个您可以使用的概念验证类：

public interface ILock : IDisposable
{
}

public class ThreadGuard
{
    private static readonly object SlotMarker = new Object();

    [ThreadStatic]
    private static Dictionary<Guid, object> locks;

    private Guid lockID;
    private object sync = new Object();

    public void BeginGuardedOperation()
    {
        lock (sync)
        {
            if (lockID == Guid.Empty)
                throw new InvalidOperationException("Guarded operation " +
                    "was blocked because no lock has been obtained.");
            object currentLock;
            Locks.TryGetValue(lockID, out currentLock);
            if (currentLock != SlotMarker)
            {
                throw new InvalidOperationException("Guarded operation " +
                    "was blocked because the lock was obtained on a " +
                    "different thread from the calling thread.");
            }
        }
    }

    public ILock GetLock()
    {
        lock (sync)
        {
            if (lockID != Guid.Empty)
                throw new InvalidOperationException("This instance is " +
                    "already locked.");
            lockID = Guid.NewGuid();
            Locks.Add(lockID, SlotMarker);
            return new ThreadGuardLock(this);
        }
    }

    private void ReleaseLock()
    {
        lock (sync)
        {
            if (lockID == Guid.Empty)
                throw new InvalidOperationException("This instance cannot " +
                    "be unlocked because no lock currently exists.");
            object currentLock;
            Locks.TryGetValue(lockID, out currentLock);
            if (currentLock == SlotMarker)
            {
                Locks.Remove(lockID);
                lockID = Guid.Empty;
            }
            else
                throw new InvalidOperationException("Unlock must be invoked " +
                    "from same thread that invoked Lock.");
        }
    }

    public bool IsLocked
    {
        get
        {
            lock (sync)
            {
                return (lockID != Guid.Empty);
            }
        }
    }

    protected static Dictionary<Guid, object> Locks
    {
        get
        {
            if (locks == null)
                locks = new Dictionary<Guid, object>();
            return locks;
        }
    }

    #region Lock Implementation

    class ThreadGuardLock : ILock
    {
        private ThreadGuard guard;

        public ThreadGuardLock(ThreadGuard guard)
        {
            this.guard = guard;
        }

        public void Dispose()
        {
            guard.ReleaseLock();
        }
    }

    #endregion
}

这里发生了很多事情，但我会为您分解：

• 当前锁（每个线程）保存在 [ThreadStatic] 字段提供类型安全、线程本地存储。该字段在 ThreadGuard 的实例之间共享，但每个实例都使用自己的密钥 (Guid)。

• 两个主要操作是GetLock，它验证没有锁被获取，然后添加自己的锁，以及ReleaseLock，它验证锁是否存在< em>对于当前线程（因为记住，locks 是ThreadStatic），如果满足条件则将其删除，否则抛出异常。

• 最后一个操作 BeginGuardedOperation 旨在由拥有 ThreadGuard 实例的类使用。它基本上是一种断言，它验证当前执行的线程是否拥有分配给此 ThreadGuard 的锁，如果不满足条件，则抛出异常。

• 还有一个 ILock 接口（除了从 IDisposable 派生之外，不执行任何操作），以及一个一次性内部 ThreadGuardLock 来实现它，它保存对创建它的 ThreadGuard 的引用，并在释放时调用其 ReleaseLock 方法。请注意，ReleaseLock 是私有的，因此 ThreadGuardLock.Dispose 是对释放函数的唯一公共访问，这很好 - 我们只想要一个获取和释放的单点入口。

要使用 ThreadGuard，您可以将其包含在另一个类中：

public class MyGuardedClass
{
    private int id;
    private string name;
    private ThreadGuard guard = new ThreadGuard();

    public MyGuardedClass()
    {
    }

    public ILock Lock()
    {
        return guard.GetLock();
    }

    public override string ToString()
    {
        return string.Format("[ID: {0}, Name: {1}]", id, name);
    }

    public int ID
    {
        get { return id; }
        set
        {
            guard.BeginGuardedOperation();
            id = value;
        }
    }

    public string Name
    {
        get { return name; }
        set
        {
            guard.BeginGuardedOperation();
            name = value;
        }
    }
}

这一切都是使用 BeginGuardedOperation 方法作为断言，如前所述。请注意，我并不是试图保护读写冲突，而只是尝试保护多重写入冲突。如果您想要读写器同步，那么您需要需要相同的读取锁（可能不太好），在 MyGuardedClass 中使用额外的锁（最简单的解决方案）或更改 < code>ThreadGuard 使用 Monitor 类公开并获取真正的“锁”（小心）。

这是一个可以使用的测试程序：

class Program
{
    static void Main(string[] args)
    {
        MyGuardedClass c = new MyGuardedClass();
        RunTest(c, TestNoLock);
        RunTest(c, TestWithLock);
        RunTest(c, TestWithDisposedLock);
        RunTest(c, TestWithCrossThreading);
        Console.ReadLine();
    }

    static void RunTest(MyGuardedClass c, Action<MyGuardedClass> testAction)
    {
        try
        {
            testAction(c);
            Console.WriteLine("SUCCESS: Result = {0}", c);
        }
        catch (Exception ex)
        {
            Console.WriteLine("FAIL: {0}", ex.Message);
        }
    }

    static void TestNoLock(MyGuardedClass c)
    {
        c.ID = 1;
        c.Name = "Test1";
    }

    static void TestWithLock(MyGuardedClass c)
    {
        using (c.Lock())
        {
            c.ID = 2;
            c.Name = "Test2";
        }
    }

    static void TestWithDisposedLock(MyGuardedClass c)
    {
        using (c.Lock())
        {
            c.ID = 3;
        }
        c.Name = "Test3";
    }

    static void TestWithCrossThreading(MyGuardedClass c)
    {
        using (c.Lock())
        {
            c.ID = 4;
            c.Name = "Test4";
            ThreadPool.QueueUserWorkItem(s => RunTest(c, cc => cc.ID = 5));
            Thread.Sleep(2000);
        }
    }
}

正如代码（希望）所暗示的那样，只有 TestWithLock 方法完全成功。 TestWithCrossThreading 方法部分成功 - 工作线程失败，但主线程没有问题（这也是这里所需的行为）。

这并不是要成为生产就绪的代码，但它应该让您了解必须做什么才能（a）防止跨线程调用和（b）允许任何线程取得该线程的所有权。对象，只要没有其他东西使用它。

Answer 3

让我们重新设计您的类，使其真正像事务一样工作。

using (var transaction = account.BeginTransaction())
{
       transaction.Name = "blah";
       transaction.Date = DateTime.Now;
       transaction.Comit();
}

在调用 commit 之前，更改不会传播。
在提交中，您可以锁定目标对象并设置其属性。

Answer 4

您可以重写 AddOne 和 RemoveOne 来获取一个布尔标志，如果从锁调用该标志，则该标志设置为 true。我看不到任何其他方法。

您还可以使用 ExecutionContext class 如果你想了解有关当前执行上下文的信息。您可以通过调用 ExecutionContext.Capture()。

Answer 5

使用线程本地存储，您可以存储锁的进入和退出。

Answer 6

如果您的要求是必须在方法 AddOne() 或 RemoveOne() 的持续时间内获取锁，那么为什么不简单地在每个方法内获取锁呢？如果调用者已经为您获取了锁，那么这应该不是问题。

但是，如果您的要求是必须在一起调用 AddOne() 和 RemoveOne() 之前获取锁（因为在实例上执行的其他并发操作可能不安全），那么也许您应该考虑更改公共接口，以便可以锁定内部处理，无需考虑客户端代码的细节。

完成后者的一种可能方法是提供必须在 AddOne 和 RemoveOne 之前和之后调用的 Begin-Changes 和 End-Changes 方法。如果在 Begin-End 范围之外调用 AddOne 或 RemoveOne，则应引发异常。

Answer 7

我遇到了同样的问题并创建了一个如下所示的帮助程序类：

public class BusyLock : IDisposable
{
    private readonly Object _lockObject = new Object();
    private int _lockCount;

    public bool IsBusy
    {
        get { return _lockCount > 0; }
    }

    public IDisposable Enter()
    {
        if (!Monitor.TryEnter(_lockObject, TimeSpan.FromSeconds(1.0)))
            throw new InvalidOperationException("Cannot begin operation as system is already busy");

        Interlocked.Increment(ref _lockCount);
        return this;
    }

    public bool TryEnter(out IDisposable busyLock)
    {
        if (Monitor.TryEnter(_lockObject))
        {
            busyLock = this;
            Interlocked.Increment(ref _lockCount);
            return true;
        }

        busyLock = null;
        return false;
    }

    #region IDisposable Members

    public void Dispose()
    {
        if (_lockCount > 0)
        {
            Monitor.Exit(_lockObject);
            Interlocked.Decrement(ref _lockCount);
        }
    }

    #endregion
}

然后您可以创建一个像这样包装的实例：

public sealed class AutomationManager
{
    private readonly BusyLock _automationLock = new BusyLock();

    public IDisposable AutomationLock
    {
        get { return _automationLock.Enter(); }
    }

    public bool IsBusy
    {
        get { return _automationLock.IsBusy; }
    }
}

并像这样使用它：

    public void DoSomething()
    {
        using (AutomationLock)
        {
            //Do important busy stuff here
        }
    }

对于我的特殊情况，我只想要一个强制锁（两个线程不应该如果他们行为良好的话，尝试同时获取锁），所以我抛出一个异常。您可以轻松修改它以执行更典型的锁定，并且仍然利用 IsBusy。