Arrêt du temporisateur dans sa méthode de rappel

J'ai un Système.Le filetage.Timer qui appelle à son gestionnaire d'événement approprié (rappel) à chaque 10 ms. La méthode elle-même est non réentrant et peut parfois prendre façon de plus de 10 ms. Donc, je veux arrêter le chronomètre lors de l'exécution de la méthode.

Code:

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 indique que la méthode de rappel est appelée chaque fois que le timer se déclenche) dans le thread du pool de threads. Cela signifie que si j'arrêt de la minuterie, la première chose dans la méthode elle n'est pas toujours impérativement prévenir la minuterie à feu et à exécuter un autre exemple de la méthode avant de la première, avait une chance d'arrêter la minuterie.

Devrait peut-être que la minuterie (ou même la non réentrante de la méthode elle-même) être verrouillée?
Quelle est la bonne façon de prévenir la minuterie de cuisson lors de l'exécution de son rappel (et non réentrant) méthode?

source d'informationauteur Kornelije Petak

c#callback reentrancy timer

45

Vous pourriez vous laisse le temps de continuer la cuisson de la méthode de rappel d'envelopper votre non réentrant code dans un Moniteur.TryEnter/Sortie. Pas besoin de s'arrêter/redémarrer le compte à rebours dans ce cas; le chevauchement des appels ne seront pas acquérir le verrou et de revenir immédiatement.
```
 private void CreatorLoop(object state) 
 {
   if (Monitor.TryEnter(lockObject))
   {
     try
     {
       //Work here
     }
     finally
     {
       Monitor.Exit(lockObject);
     }
   }
 }
```
6

Quelques solutions possibles:
- ont fait le vrai boulot dans encore un autre thread délégué qui est en attente d'un événement. La minuterie de rappel simplement les signaux de l'événement. Le thread de travail ne peut pas être ressaisie, comme c'est un seul thread qui fait son travail que lorsque l'événement est signalé. La minuterie est réentrant, car il n'est de signaler l'événement (semble un peu rond-point et inutile, mais ça va marcher)
- ont la minuterie créé avec seulement un délai d'attente de démarrage et pas de périodique délai d'attente de sorte qu'il va en tirer qu'une seule fois. La minuterie de rappel va disposer de l'objet timer et en créer un nouveau, quand il a terminé son travail, qui fera également déclencher une seule fois.
Vous pouvez être en mesure de gérer l'option n ° 2 sans disposer/création d'un nouvel objet à l'aide de la Change() méthode de l'original de l'objet timer, mais je ne suis pas sûr de ce que le comportement est exactement à l'appel de Change() avec un nouveau délai d'attente de démarrage après le premier délai d'attente a expiré. Que serait la valeur d'un test ou deux.

Edit:

J'ai fait le test de la manipulation de la minuterie comme un redémarrage one-shot semble fonctionner parfaitement, et c'est beaucoup plus simple que les autres méthodes. Voici un exemple de code basé sur le vôtre, en tant que point de départ (un peu de détails ont peut-être changé pour la compiler sur ma machine):
```
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);
}
```

J'ai eu la même situation avec un Système.Les minuteries.À rebours, où le temps écoulé événement est exécuté à partir d'un pool de threads et doit être réentrant.

J'ai utilisé cette méthode pour contourner le problème:

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

En fonction de ce que vous faites, vous pourriez envisager d'utiliser un Système.Les minuteries.Minuterie, voici un bon résumé de 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)

Je le fais avec Contrefil qui propose des opérations atomiques, et par CompareExchange assure qu'un seul thread à la fois entre la section critique:

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

    }

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

Vous devez vous connecter pour publier un commentaire.