专用线程锁定对象的命名约定

这是一个相对较小的问题，但我无法找到官方文档，甚至找不到关于它的博客意见/讨论。

简而言之：当我有一个私有对象，其唯一目的是为私有服务时lock，该对象该如何命名？

class MyClass
{
    private object LockingObject = new object();

    void DoSomething()
    {
        lock(LockingObject)
        {
            //do something
        }
    }
}

我们LockingObject在这里应该命名什么？还不仅要考虑变量的名称，还要考虑变量在锁定时的代码外观。

我看过各种示例，但似乎没有可靠的建议：

1. SyncRoot（和的各种变体形式_syncRoot）的用法很多。

   • 代码示例： lock(SyncRoot)，lock(_syncRoot)
   • 这似乎受到VB的等效SyncLock语句，SyncRoot某些ICollection类上存在的属性以及某种SyncRoot设计模式的一部分的影响（这可能是一个坏主意）
   • 在C＃上下文中，不确定是否要使用VBish命名。更糟糕的是，在VB中将变量命名为与关键字相同。不知道这是否会引起混乱。

2. thisLock并lockThis来自MSDN文章：C＃lock语句，VB SyncLock语句

   • 代码示例： lock(thisLock)，lock(lockThis)
   • 不知道这些名称是否仅出于示例目的而最少命名
   • 如果我们在static类/方法中使用它，那有点奇怪。
   • 编辑：关于锁的Wikipedia文章也使用此命名作为其示例

3. PadLock（不同大小写的）的几种用法

   • 代码示例： lock(PadLock)，lock(padlock)
   • 不错，但是我唯一的牛肉就是它毫无意外地调用了物理 “挂锁” 的图像，而我倾向于将其与抽象线程概念无关。

4. 根据锁定意图命名锁定

   • 代码示例： lock(messagesLock)，lock(DictionaryLock)，lock(commandQueueLock)
   • 在VB SyncRoot MSDN页面示例中，它包含一个simpleMessageList带有私有messagesLock对象的示例
   • 我认为将锁命名为您要锁定的类型（“ DictionaryLock”）不是一个好主意，因为这可能会更改实现细节。我更喜欢围绕要锁定的概念/对象命名（“ messagesLock”或“ commandQueueLock”）
   • 有趣的是，我很少在网上或StackOverflow上看到这种用于锁定对象的命名约定。

5. （编辑）“ 8.12 The Lock Statement”部分下的C＃规范提供了此模式的示例并将其命名 synchronizationObject

   • 代码示例： lock(SynchronizationObject)，lock(synchronizationObject)

问题： 您对命名私有锁定对象有何一般看法？

最近，我开始命名它们ThreadLock（有点像选项3），但是我发现自己在问那个名字。

我在整个应用程序中经常使用这种锁定模式（在上面提供的代码示例中），因此我认为对它们的可靠命名约定进行更为专业的意见/讨论可能是有意义的。谢谢！

我已经习惯了SomeResourceLock在SomeResource需要锁来访问/更新的地方调用它的习惯，即（原谅任何线程问题，这只是一个例证）

public class ProcessDataInQueue
{
    private static Queue<Data> _dataQueue = new Queue<Data>();
    private static object _dataQueueLock = new Object();

    public void AddOneItem(Data itemToAdd)
    {
        lock(_dataQueueLock)
        {
            _dataQueue.Enqueue(itemToAdd);
        }
    }

    public void ProcessOneItem()
    {
        Data itemToProcess = null;
        lock(_dataQueueLock)
        {
            itemToProcess = _dataQueue.Dequeue();
        }
        // ... process itemToProcess
    }
}

我在拥有可能为不同资源使用多个锁的类之后就养成了这种习惯，因此我根据锁定对象对访问的资源命名来命名锁定对象。有时一个对象可能锁定多个资源，在这种情况下，我将尝试使名称以某种方式受到尊重，因此读者知道“针对那些单个资源的其他锁定也将与此锁定竞争”。

我通常将其称为locker，但是由于它是私有的，因此我认为这是一个不太重要的实现细节。首先，请使用您团队/公司的标准。如果没有，那么请制造并使用它，但在制造过程中，请保持简单。如果您的类只有一个锁定对象，则对其进行调用就foo足够了。如果您有很多人，一个很好的业务订单可能只是首先重新访问该类的设计，以查看它是否在做太多不同的事情。但是，如果不是这样，则名称变得很重要，如下面的示例所示：

public sealed class CustomerOrders
{
    private readonly object customerLocker = new object();

    private readonly object orderLocker = new object();

    public IEnumerable<Customer> Customers
    {
        get
        {
            lock (this.cutomerLocker)
            lock (this.orderLocker)
            {
                // stuff...
            }
        }

        set
        {
            lock (this.cutomerLocker)
            lock (this.orderLocker)
            {
                // other stuff...
            }
        }
    }

    public IEnumerable<Order> Orders
    {
        get
        {
            lock (this.orderLocker)
            {
                // stuff...
            }
        }

        set
        {
            lock (this.cutomerLocker)
            {
                // different stuff...
            }
        }
    }
}

我一直使用lck_。这样，如果您按ctrl + f“ lck”，则只应找到锁，而“ lock”也将找到“ clock”之类的东西。

诸如lockThis和Padlock之类的东西对于uni投资组合来说很好，但是对于适当的项目，您应该真正使用语义名称，这样，当您查看声明时，就可以知道对象的实际作用而无需搜索代码。