Warum muss das Sperrobjekt statisch sein?

Es ist sehr üblich, ein privates statisches schreibgeschütztes Objekt zum Sperren von Multithreading zu verwenden. Ich verstehe, dass privat die Eintrittspunkte zum Sperrobjekt reduziert, indem die Kapselung verschärft wird und daher auf das Wesentlichste zugegriffen wird.

Aber warum statisch?

private static readonly object Locker = new object();

Am Ende wird das Feld nur in meiner Klasse verwendet, und ich könnte stattdessen auch nur Folgendes verwenden:

private readonly object Locker = new object();

Irgendwelche Kommentare?

AKTUALISIEREN:

Als Beispiel habe ich diesen Code eingefügt (nur ein Beispiel). Ich könnte ein statisches oder nicht statisches Schließfach verwenden und beide würden gut funktionieren. In Anbetracht der folgenden Antwort sollte ich mein Schließfach eher so definieren? (Entschuldigung, ich habe nächste Woche ein Interview und muss jedes Detail kennen :)

private readonly object Locker = new object();

Und hier ist der Code:

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

Vielen Dank

Es ist nicht "sehr üblich, ein privates statisches schreibgeschütztes Objekt zum Sperren in Multithreading zu verwenden", sondern es ist üblich, eine Sperre mit der entsprechenden / gewählten Granularität zu verwenden . Manchmal ist das so static. Meistens, IMO, ist es nicht - aber es ist instanzbasiert .

Die Hauptzeit, in der Sie eine staticSperre sehen, ist für einen globalen Cache oder für das verzögerte Laden globaler Daten / Singletons. Und in letzterem gibt es sowieso bessere Möglichkeiten .

Es kommt also wirklich darauf an: Wie wird Lockeres in Ihrem Szenario verwendet? Schützt es etwas, das selbst statisch ist? In diesem Fall sollte das Schloss statisch sein. Wenn es etwas zu schützen , die ist Instanz basiert, dann IMO sollte die Sperre auch Instanz basiert.

Es muss nicht statisch sein, manchmal sollte es auch nicht statisch sein.

Die Variable sollte sich im selben Bereich befinden wie die Methoden, mit denen Sie sie zum Sperren verwenden. Wenn die Methoden statisch sind, sollte die Variable statisch sein, und wenn die Methoden Instanzmethoden sind, sollte die Variable eine Instanzvariable sein.

Eine statische Variable funktioniert weiterhin, wenn sie zum Sperren einer Instanzmethode verwendet wird, aber dann werden Sie zu viel sperren. Sie sperren alle Methoden in allen Instanzen, nicht nur die Methoden in derselben Instanz.

Der Umfang und die Lebensdauer eines Schlosses können / sollten von dem 'Ding' abhängen, das Sie sperren möchten. Statische Sperren werden meistens verwendet, um statische Dinge zu sperren.