Arresto del timer nel suo metodo di richiamata

Question

Ho un System.Threading.Timer che chiama il relativo gestore di eventi (callback) ogni 10 ms. Il metodo stesso è non rientrante e talvolta può richiedere molto più lungo di 10 ms. Pertanto, voglio interrompere il timer durante l'esecuzione del metodo.

Codice:

private Timer _creatorTimer; 

// BackgroundWorker's work 
private void CreatorWork(object sender, DoWorkEventArgs e) { 
     _creatorTimer = new Timer(CreatorLoop, null, 0, 10); 

     // some other code that worker is doing while the timer is active 
     // ... 
     // ... 
} 

private void CreatorLoop(object state) { 
     // Stop timer (prevent reentering) 
     _creatorTimer.Change(Timeout.Infinite, 0); 

     /* 
      ... Work here 
     */ 

     // Reenable timer 
     _creatorTimer.Change(10, 0); 
} 

MSDN afferma che il metodo di callback viene chiamato (ogni volta che il timer incendi) in thread separato dal pool di thread. Ciò significa che se interrompo il timer, la prima cosa nel metodo non impedisce necessariamente al timer di sparare ed eseguire un'altra istanza del metodo prima che il primo avesse la possibilità di fermare il timer.

Dovrebbe forse essere bloccato il timer (o anche il metodo non rientrante)? Qual è il modo giusto per evitare che il timer si attivi durante l'esecuzione del suo metodo di callback (e non rientranti)?

Answer 1

È possibile che il timer continui a attivare il metodo di richiamata, ma avvolgere il codice non rientrante in Monitor.TryEnter/Exit. In questo caso non è necessario arrestare/riavviare il timer; le chiamate sovrapposte non acquisiranno il blocco e torneranno immediatamente.

private void CreatorLoop(object state) 
{ 
    if (Monitor.TryEnter(lockObject)) 
    { 
    try 
    { 
     // Work here 
    } 
    finally 
    { 
     Monitor.Exit(lockObject); 
    } 
    } 
} 

Answer 2

Ho avuto una situazione simile con un System.Timers.Timer, in cui l'evento trascorso viene eseguito da un threadpool e deve essere rientranti.

Ho usato questo metodo per aggirare il problema:

private void tmr_Elapsed(object sender, EventArgs e) 
{ 
    tmr.Enabled = false; 
    // Do Stuff 
    tmr.Enabled = true; 
} 

A seconda di quello che stai facendo si può prendere in considerazione uno System.Timers.Timer, ecco un bel riassunto da MSDN

          System.Windows.Forms System.Timers   System.Threading 
Timer event runs on what thread?   UI thread    UI or worker thread Worker thread 
Instances are thread safe?    No      Yes     No 
Familiar/intuitive object model?   Yes      Yes     No 
Requires Windows Forms?     Yes      No     No 
Metronome-quality beat?     No      Yes*     Yes* 
Timer event supports state object?  No      No     Yes 
Initial timer event can be scheduled? No      No     Yes 
Class supports inheritance?    Yes      Yes     No 

* Depending on the availability of system resources (for example, worker threads)    

Answer 3

Un paio di possibili soluzioni:

• hanno il vero lavoro fatto in un altro delegato filo che è in attesa di un evento. La richiamata del timer segnala semplicemente l'evento. Il thread di lavoro non può essere reinserito, poiché è un singolo thread che funziona solo quando viene segnalato l'evento. Il timer è rientrante, poiché tutto ciò che fa è segnalare l'evento (sembra un po 'rotatorio e dispendioso, ma funzionerà)
• avere il timer creato con solo un timeout di inizio e nessun timeout periodico in modo che si spari solo una volta . Il callback del timer eliminerà quell'oggetto timer e ne creerà uno nuovo quando avrà completato il suo lavoro, che verrà attivato anche una sola volta.

Si può essere in grado di gestire l'opzione # 2 senza smaltimento/creazione di un nuovo oggetto utilizzando il metodo dell'oggetto temporizzatore originale Change(), ma non sono sicuro di quello che il comportamento è esattamente di chiamare Change() con un nuovo avvia il timeout dopo che è scaduto il primo timeout. Questo varrebbe la pena di fare un test o due.

Edit:

---

Ho fatto il test - manipolare il timer come riavviabile one-shot sembra funzionare perfettamente, ed è molto più semplice rispetto agli altri metodi.Ecco alcuni esempi di codice sulla base di vostro come punto di partenza (alcuni dettagli potrebbero essere cambiati per farlo compilare sulla mia macchina):

private Timer _creatorTimer; 

// BackgroundWorker's work 
private void CreatorWork(object sender, EventArgs e) { 
    // note: there's only a start timeout, and no repeat timeout 
    // so this will fire only once 
    _creatorTimer = new Timer(CreatorLoop, null, 1000, Timeout.Infinite); 

    // some other code that worker is doing while the timer is active 
    // ... 
    // ... 
} 

private void CreatorLoop(object state) { 
    Console.WriteLine("In CreatorLoop..."); 
    /* 
     ... Work here 
    */ 
    Thread.Sleep(3000); 

    // Reenable timer 
    Console.WriteLine("Exiting..."); 

    // now we reset the timer's start time, so it'll fire again 
    // there's no chance of reentrancy, except for actually 
    // exiting the method (and there's no danger even if that 
    // happens because it's safe at this point). 
    _creatorTimer.Change(1000, Timeout.Infinite); 
} 

Answer 4

lo faccio con Interlocked che fornisce operazioni atomiche, e CompareExchange assicura che solo un thread alla volta entra nella sezione critica:

private int syncPoint = 0; 

private void Loop() 
    { 
     int sync = Interlocked.CompareExchange(ref syncPoint, 1, 0); 
     //ensures that only one timer set the syncPoint to 1 from 0 
     if (sync == 0) 
     { 
      try 
      { 
       ... 
      } 
      catch (Exception pE) 
      { 
       ... 
      } 
      syncPoint = 0; 
     } 

    } 

Answer 5

//using Timer with callback on System.Threading namespace 
    // Timer(TimerCallback callback, object state, int dueTime, int period); 
    //  TimerCallback: delegate to callback on timer lapse 
    //  state: an object containig information for the callback 
    //  dueTime: time delay before callback is invoked; in milliseconds; 0 immediate 
    //  period: interval between invocation of callback; System.Threading.Timeout.Infinity to disable 
    // EXCEPTIONS: 
    //  ArgumentOutOfRangeException: negative duration or period 
    //  ArgumentNullException: callback parameter is null 

    public class Program 
    { 
     public void Main() 
     { 
      var te = new TimerExample(1000, 2000, 2); 
     } 
    } 

    public class TimerExample 
    { 
     public TimerExample(int delayTime, int intervalTime, int treshold) 
     { 
      this.DelayTime = delayTime; 
      this.IntervalTime = intervalTime; 
      this.Treshold = treshold; 
      this.Timer = new Timer(this.TimerCallbackWorker, new StateInfo(), delayTime, intervalTime); 
     } 

     public int DelayTime 
     { 
      get; 
      set; 
     } 

     public int IntervalTime 
     { 
      get; 
      set; 
     } 

     public Timer Timer 
     { 
      get; 
      set; 
     } 

     public StateInfo SI 
     { 
      get; 
      set; 
     } 

     public int Treshold 
     { 
      get; 
      private set; 
     } 

     public void TimerCallbackWorker(object state) 
     { 
      var si = state as StateInfo; 

      if (si == null) 
      { 
       throw new ArgumentNullException("state"); 
      } 

      si.ExecutionCounter++; 

      if (si.ExecutionCounter > this.Treshold) 
      { 
       this.Timer.Change(Timeout.Infinite, Timeout.Infinite); 
       Console.WriteLine("-Timer stop, execution reached treshold {0}", this.Treshold); 
      } 
      else 
      { 
       Console.WriteLine("{0} lapse, Time {1}", si.ExecutionCounter, si.ToString()); 
      } 
     } 

     public class StateInfo 
     { 
      public int ExecutionCounter 
      { 
       get; 
       set; 
      } 

      public DateTime LastRun 
      { 
       get 
       { 
        return DateTime.Now; 
       } 
      } 

      public override string ToString() 
      { 
       return this.LastRun.ToString(); 
      } 
     } 
    } 

    // Result: 
    // 
    // 1 lapse, Time 2015-02-13 01:28:39 AM 
    // 2 lapse, Time 2015-02-13 01:28:41 AM 
    // -Timer stop, execution reached treshold 2 
    //