Czy to prawidłowy projekt synchronizacji synchronicznej?

Question

Mam system, który pobiera próbki. Mam wiele wątków klienta w aplikacji, które są zainteresowane tymi próbkami, ale rzeczywisty proces pobierania próbki może nastąpić tylko w jednym kontekście. Jest wystarczająco szybki, aby zablokować proces wywoływania, dopóki nie zostanie wykonane próbkowanie, ale na tyle wolny, że nie chcę, aby wiele wątków zgłaszało żądania. Wpadłem z tym wzorem (okrojona do minimalnych informacji):

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 
    } 
} 

Czy to bezpieczne dla stosowania w scenariuszu opisałem?

Answer 1

Tak, wygląda bezpiecznie, ponieważ int jest tutaj typem atomowym. Ale chciałbym jeszcze doradzić zastępując

private static int _isSampling; 

z

private static object _samplingLock = new object(); 

i zastosowanie:

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

Po prostu dlatego, że jest zalecany wzór, a także sprawia, że ​​wszystkie dostępu do _lastSample jest traktowane poprawnie.

NB: Spodziewałbym się prędkości porównywalnej, blokada korzysta z zarządzanej klasy monitora, która wewnętrznie korzysta z blokowania.

Edit:

Tęskniłem aspekt back-off, tutaj jest inna wersja:

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

Answer 2

zwykle deklarują lotny bool i zrobić coś takiego:

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