synlock - thread synchronization c#

¿Por qué el objeto de bloqueo debe ser estático?

Question

Es muy común usar un objeto privado de lectura estática para bloquear en múltiples subprocesos. Entiendo que privado reduce los puntos de entrada al objeto de bloqueo al apretar la encapsulación y, por lo tanto, acceder a la más esencial.

Pero, ¿por qué estático?

private static readonly object Locker = new object();

Al final, el campo solo se usa dentro de mi clase, y también podría usar esto en su lugar:

private readonly object Locker = new object();

¿Algún comentario?

ACTUALIZAR:

Como ejemplo, he pegado este código (solo un ejemplo). Podría usar un casillero estático o no estático en esto y ambos funcionarían bien. Considerando la respuesta a continuación, ¿debería definir mi casillero así? (Lo siento, tengo una entrevista la próxima semana y necesito saber cada detalle :)

private readonly object Locker = new object();

Y aquí está el 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();
        }

Gracias

Answer 1

El alcance y la duración de un bloqueo pueden / deben depender de la "cosa" que desea bloquear. Los bloqueos estáticos se usan principalmente para bloquear cosas estáticas.

Answer 2

No es "muy común usar un objeto privado de lectura estática para bloquear en multihebra", sino que es común usar un candado en la granularidad apropiada / elegida . A veces eso es static . Más a menudo, IMO, no lo es, pero está basado en instancias .

La hora principal en que ve un bloqueo static es para un caché global o para la carga diferida de datos globales / singletons. Y en este último, hay mejores formas de hacerlo de todos modos .

Entonces realmente depende: ¿cómo se usa Locker en su escenario? ¿Está protegiendo algo que es estático? Si es así, la cerradura debe ser estática. Si está protegiendo algo basado en instancias , entonces IMO, el bloqueo, también debe estar basado en instancias.

Answer 3

No tiene que ser estático, de hecho, a veces no debe ser estático.

La variable debe vivir en el mismo ámbito que los métodos donde la usa para el bloqueo. Si los métodos son estáticos, la variable debe ser estática, y si los métodos son métodos de instancia, la variable debe ser una variable de instancia.

Una variable estática seguirá funcionando cuando se use para bloquear un método de instancia, pero luego se bloqueará demasiado. Bloqueará todos los métodos en todas las instancias, no solo los métodos en la misma instancia.