¿Es este un diseño de sincronización entrelazado correcto?

Question

Tengo un sistema que toma muestras. Tengo varios hilos de clientes en la aplicación que están interesados ​​en estos ejemplos, pero el proceso real de tomar una muestra solo puede ocurrir en un contexto. Es lo suficientemente rápido como para bloquear el proceso de llamada hasta que se realiza el muestreo, pero lo suficientemente lento como para no querer que varios hilos acumulen solicitudes. Se me ocurrió con este diseño (pelado abajo a los detalles mínimos):

public class Sample 
{ 
    private static Sample _lastSample; 
    private static int _isSampling; 

    public static Sample TakeSample(AutomationManager automation) 
    { 
     //Only start sampling if not already sampling in some other context 
     if (Interlocked.CompareExchange(ref _isSampling, 0, 1) == 0) 
     { 
      try 
      { 
       Sample sample = new Sample(); 
       sample.PerformSampling(automation); 
       _lastSample = sample; 
      } 
      finally 
      { 
       //We're done sampling 
       _isSampling = 0; 
      } 
     } 

     return _lastSample; 
    } 

    private void PerformSampling(AutomationManager automation) 
    { 
     //Lots of stuff going on that shouldn't be run in more than one context at the same time 
    } 
} 

Es esto seguro para su uso en el escenario que he descrito?

Answer 1

Sí, parece seguro porque int es un tipo atómico aquí. Pero aun así, aconsejo la sustitución

private static int _isSampling; 

con

private static object _samplingLock = new object(); 

y uso:

lock(_samplingLock) 
{ 
    Sample sample = new Sample(); 
    sample.PerformSampling(automation); 
    _lastSample = sample; 
} 

Simplemente porque es el patrón recomendado y también se asegura de todos los accesos a _lastSample es tratado correctamente.

NB: Esperaría una velocidad comparable, el bloqueo utiliza la clase de Monitor administrado que usa enclavamiento interno.

Editar:

echaba de menos el aspecto de back-off, aquí es otra versión:

if (System.Threading.Monitor.TryEnter(_samplingLock)) 
    { 
    try 
    { 
     .... // sample stuff 
    } 
    finally 
    { 
      System.Threading.Monitor.Exit(_samplingLock); 
    } 
    } 

Answer 2

lo general declaran un bool volátil y hacer algo como:

private volatile bool _isBusy; 
private static Sample _lastSample; 

private Sample DoSomething() 
{ 
    lock(_lastSample) 
    { 
     if(_isBusy) 
      return _lastSample; 
     _isBusy = true; 
    } 

    try 
    { 
     _lastSample = new sameple//do something 
    } 
    finally 
    { 
     lock(_lastSample) 
     { 
      _isBusy = false; 
     } 
    } 
    return _lastSample; 
}