为什么锁对象必须是静态的？

使用私有静态只读对象进行多线程锁定非常普遍。我了解到，private通过拧紧封装减少了锁定对象的入口，因此可以访问最基本的对象。

但是为什么要静态呢？

private static readonly object Locker = new object();

最后，该字段仅在我的班级中使用，我也可以只使用它：

private readonly object Locker = new object();

任何意见？

更新：

作为示例，我粘贴了此代码（仅作为示例）。我可以在此上使用静态或非静态储物柜，并且两者都可以正常工作。考虑下面的答案，我应该像这样定义我的储物柜？（对不起，下周我要接受采访，需要了解每个细节：）

private readonly object Locker = new object();

这是代码：

    private int _priceA;
    private int _priceB;
    private EventWaitHandle[] _waithandle;
    private readonly IService _service;

//ctor
public ModuleAViewModel(IService service)
    {
        _service = service;
        _modelA = new ModelA();
        _waithandle = new ManualResetEvent[2];
        _waithandle[0] = new ManualResetEvent(false);
        _waithandle[1] = new ManualResetEvent(false);
        LoadDataByThread();
    }


 private void LoadDataByThread()
        {
            new Thread(() =>
                           {
                               new Thread(() =>
                               {
                                   lock (Locker)
                                   {
                                       _priceA = _service.GetPriceA();
                                   }
                                   _waithandle[0].Set();
                               }).Start();

                               new Thread(() =>
                               {
                                   lock (Locker)
                                   {
                                       _priceB = _service.GetPriceB();
                                   }
                                   _waithandle[1].Set();
                               }).Start();

                               WaitHandle.WaitAll(_waithandle);
                               PriceA = _priceA;
                               PriceB = _priceB;
                           }).Start();
        }

谢谢

“使用私有静态只读对象进行多线程锁定不是很常见”，而是以适当/选定的粒度使用锁定。有时候就是这样static。IMO通常不是，而是基于实例的。

您看到static锁定的主要时间是用于全局缓存，或用于延迟加载全局数据/单例。在后者中，无论如何都有更好的方法。

因此，这实际上取决于：Locker您的方案如何使用？它在保护本身就是静态的东西吗？如果是这样，则锁应该是静态的。如果保护的是基于实例的内容，则IMO锁也应基于实例。

它不必是静态的，其实有时它应该不会是一成不变的。

该变量应与用于锁定的方法处于同一范围内。如果方法是静态的，则变量应为静态，如果方法是实例的方法，则变量应为实例变量。

当用于锁定实例方法时，静态变量仍然可以使用，但是您将被锁定过多。您将锁定所有实例中的所有方法，而不仅仅是同一实例中的方法。

锁的范围和寿命可以/应该取决于您要锁定的“事物”。静态锁通常用于锁定静态事物。