Dlaczego obiekt zamka musi być statyczny?

Bardzo często używa się prywatnego statycznego obiektu tylko do odczytu do blokowania w wielowątkowości. Rozumiem, że prywatny zmniejsza punkty wejścia do obiektu blokującego poprzez uszczelnienie hermetyzacji, a tym samym dostęp do najistotniejszych.

Ale dlaczego statyczne?

private static readonly object Locker = new object();

Na końcu pole jest używane tylko w mojej klasie, a zamiast tego mógłbym też po prostu użyć tego:

private readonly object Locker = new object();

Jakieś uwagi?

AKTUALIZACJA:

Jako przykład wkleiłem ten kod (tylko przykład). Mógłbym użyć do tego statycznej lub niestatycznej szafki i oba będą działać dobrze. Biorąc pod uwagę odpowiedź poniżej, powinienem raczej zdefiniować moją szafkę w ten sposób? (Przepraszam, że mam wywiad w przyszłym tygodniu i muszę znać każdy szczegół :)

private readonly object Locker = new object();

A oto kod:

    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();
        }

Dzięki

Nie jest „bardzo powszechne używanie prywatnego statycznego obiektu tylko do odczytu do blokowania w wielowątkowości” - raczej często używa się blokady na odpowiednim / wybranym poziomie szczegółowości . Czasami tak jest static. Częściej IMO tak nie jest - ale jest oparte na instancji .

Główny czas, w którym widzisz staticblokadę, dotyczy globalnej pamięci podręcznej lub odroczonego ładowania globalnych danych / singletonów. A w tym ostatnim, że są lepsze sposoby robi to w każdym razie .

Więc to naprawdę zależy: jak jest Lockerużywane w twoim scenariuszu? Czy chroni coś, co samo w sobie jest statyczne? Jeśli tak, zamek powinien być statyczny. Jeśli chroni coś, co jest oparte na instancjach , wówczas blokada IMO powinna również być oparta na instancjach.

To nie musi być statyczne, w rzeczywistości czasami powinno nie być statyczne.

Zmienna powinna znajdować się w tym samym zakresie, co metody, w których jest używana do blokowania. Jeśli metody są statyczne, zmienna powinna być statyczna, a jeśli metody są metodami instancji, zmienna powinna być zmienną instancji.

Zmienna statyczna będzie nadal działać, gdy zostanie użyta do blokowania w metodzie instancji, ale wtedy będziesz blokować zbyt mocno. Zablokujesz wszystkie metody we wszystkich instancjach, a nie tylko metody w tej samej instancji.

Zakres i żywotność blokady może / powinna zależeć od „rzeczy”, którą chcesz zablokować. Blokady statyczne są najczęściej używane do blokowania elementów statycznych.