Por que o objeto de bloqueio precisa ser estático?

É muito comum usar um objeto somente leitura estático privado para bloqueio em multiencadeamento. Eu entendo que privado reduz os pontos de entrada para o objeto de bloqueio, apertando o encapsulamento e, portanto, o acesso ao mais essencial.

Mas por que estático?

private static readonly object Locker = new object();

No final, o campo é usado apenas dentro da minha classe, e eu também poderia usar apenas este:

private readonly object Locker = new object();

Algum comentário?

ATUALIZAR:

Como exemplo, colei este código (apenas um exemplo). Eu poderia usar um armário estático ou não estático nisso e ambos funcionariam bem. Considerando a resposta abaixo, eu deveria definir meu armário dessa maneira? (Desculpe, tenho uma entrevista na próxima semana e preciso saber todos os detalhes :)

private readonly object Locker = new object();

E aqui está o código:

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

obrigado

Não é "muito comum usar um objeto somente leitura estático privado para bloqueio em multithreading" - em vez disso, é comum usar um bloqueio na granularidade apropriada / escolhida . Às vezes sim static. Mais frequentemente, IMO, não é - mas é baseado em instância .

O principal momento em que você vê um staticbloqueio é para um cache global ou para o carregamento adiado de dados globais / singletons. E no último, existem maneiras melhores de fazer isso de qualquer maneira .

Então realmente depende: como é Lockerusado no seu cenário? Trata-se de proteger algo que é em si estática? Nesse caso, o bloqueio deve ser estático. Se estiver protegendo algo que é baseado em instância , o bloqueio IMO também deve ser baseado em instância.

Ele não tem que ser estático, na verdade, por vezes, ele deve não ser estática.

A variável deve residir no mesmo escopo dos métodos onde você a usa para bloqueio. Se os métodos são estáticos, a variável deve ser estática, e se os métodos são métodos de instância, a variável deve ser uma variável de instância.

Uma variável estática ainda funcionará quando usada para bloquear em um método de instância, mas você estará bloqueando demais. Você bloqueará todos os métodos em todas as instâncias, não apenas os métodos na mesma instância.

O escopo e a vida útil de uma fechadura podem / devem depender da 'coisa' que você deseja bloquear. Os bloqueios estáticos são usados ​​principalmente para bloquear coisas estáticas.