Perché l'oggetto blocco deve essere statico?

È molto comune utilizzare un oggetto di sola lettura statico privato per il blocco nel multi threading. Capisco che privato riduce i punti di ingresso all'oggetto di blocco stringendo l'incapsulamento e quindi l'accesso al più essenziale.

Ma perché statico?

private static readonly object Locker = new object();

Alla fine il campo viene utilizzato solo all'interno della mia classe, e potrei anche usare solo questo:

private readonly object Locker = new object();

Eventuali commenti?

AGGIORNARE:

Come esempio ho incollato questo codice (solo un esempio). Potrei usare un armadietto statico o non statico su questo ed entrambi funzionerebbero bene. Considerando la risposta di seguito, dovrei piuttosto definire il mio armadietto in questo modo? (Scusa, ho un colloquio la prossima settimana e ho bisogno di conoscere ogni dettaglio :)

private readonly object Locker = new object();

Ed ecco il codice:

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

Grazie

Non è "molto comune utilizzare un oggetto di sola lettura statico privato per il blocco in multi threading" - piuttosto, è comune utilizzare un blocco con la granularità appropriata / scelta . A volte lo è static. Più spesso, IMO, non lo è, ma è un'istanza basato .

Il momento principale in cui vedi un staticblocco è per una cache globale o per il caricamento differito di dati / singleton globali. E in quest'ultimo caso, ci sono modi migliori per farlo comunque .

Quindi dipende davvero: come viene Lockerutilizzato nel tuo scenario? Protegge qualcosa che è di per sé statico? In tal caso, il blocco dovrebbe essere statico. Se sta proteggendo qualcosa che è basato sull'istanza , allora IMO il blocco dovrebbe anche essere basato sull'istanza.

Esso non deve essere statico, infatti a volte si deve non essere statico.

La variabile dovrebbe risiedere nello stesso ambito dei metodi in cui viene utilizzata per il blocco. Se i metodi sono statici, la variabile dovrebbe essere statica e se i metodi sono metodi di istanza, la variabile dovrebbe essere una variabile di istanza.

Una variabile statica continuerà a funzionare quando viene utilizzata per bloccare un metodo di istanza, ma in tal caso verrà bloccato troppo. Bloccherai tutti i metodi in tutte le istanze, non solo i metodi nella stessa istanza.

L'ambito e la durata di un lucchetto possono / devono dipendere dalla "cosa" che si desidera bloccare. I blocchi statici vengono utilizzati principalmente per bloccare cose statiche.