Les minuteries C # s'écoulent-elles sur un thread séparé?

Un System.Timers.Timer s'écoule-t-il sur un thread distinct de celui qui l'a créé?

Disons que j'ai une classe avec une minuterie qui se déclenche toutes les 5 secondes. Lorsque la minuterie se déclenche, dans la méthode écoulée, un objet est modifié. Disons que cela prend beaucoup de temps pour modifier cet objet, comme 10 secondes. Est-il possible que je rencontre des collisions de threads dans ce scénario?

Pour System.Timers.Timer :

Voir la réponse de Brian Gideon ci-dessous

Pour System.Threading.Timer :

La documentation MSDN sur les minuteries indique:

La classe System.Threading.Timer effectue des rappels sur un thread ThreadPool et n'utilise pas du tout le modèle d'événement.

Donc, en effet, la minuterie s'écoule sur un fil différent.

Ça dépend. Le System.Timers.Timera deux modes de fonctionnement.

Si SynchronizingObjectest défini sur une ISynchronizeInvokeinstance, l' Elapsedévénement s'exécutera sur le thread hébergeant l'objet de synchronisation. Habituellement, ces ISynchronizeInvokeinstances ne sont rien d'autre que des instances anciennes Controlet des Forminstances que nous connaissons tous. Donc, dans ce cas, l' Elapsedévénement est appelé sur le thread d'interface utilisateur et il se comporte de la même manière que le System.Windows.Forms.Timer. Sinon, cela dépend vraiment de l' ISynchronizeInvokeinstance spécifique qui a été utilisée.

Si SynchronizingObjectest null, l' Elapsedévénement est appelé sur un ThreadPoolthread et se comporte de la même manière que le System.Threading.Timer. En fait, il utilise en fait un System.Threading.Timerdans les coulisses et effectue l'opération de marshaling après avoir reçu le rappel du minuteur si nécessaire.

Chaque événement écoulé se déclenchera dans le même thread à moins qu'un précédent Elapsed ne soit toujours en cours d'exécution.

Donc, il gère la collision pour vous

essayez de mettre ça dans une console

static void Main(string[] args)
{
    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
    var timer = new Timer(1000);
    timer.Elapsed += timer_Elapsed;
    timer.Start();
    Console.ReadLine();
}

static void timer_Elapsed(object sender, ElapsedEventArgs e)
{
    Thread.Sleep(2000);
    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
}

vous obtiendrez quelque chose comme ça

10
6
12
6
12

où 10 est le thread appelant et 6 et 12 sont déclenchés à partir de l'événement bg elapsed. Si vous supprimez le Thread.Sleep (2000); vous obtiendrez quelque chose comme ça

10
6
6
6
6

Puisqu'il n'y a pas de collisions.

Mais cela vous laisse toujours un problème. si vous déclenchez l'événement toutes les 5 secondes et qu'il faut 10 secondes pour le modifier, vous avez besoin d'un verrouillage pour ignorer certaines modifications.

Pour System.Timers.Timer, sur un thread distinct, si SynchronizingObject n'est pas défini.

    static System.Timers.Timer DummyTimer = null;

    static void Main(string[] args)
    {
        try
        {

            Console.WriteLine("Main Thread Id: " + System.Threading.Thread.CurrentThread.ManagedThreadId);

            DummyTimer = new System.Timers.Timer(1000 * 5); // 5 sec interval
            DummyTimer.Enabled = true;
            DummyTimer.Elapsed += new System.Timers.ElapsedEventHandler(OnDummyTimerFired);
            DummyTimer.AutoReset = true;

            DummyTimer.Start();

            Console.WriteLine("Hit any key to exit");
            Console.ReadLine();
        }
        catch (Exception Ex)
        {
            Console.WriteLine(Ex.Message);
        }

        return;
    }

    static void OnDummyTimerFired(object Sender, System.Timers.ElapsedEventArgs e)
    {
        Console.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId);
        return;
    }

Sortie vous verriez si DummyTimer s'est déclenché à 5 secondes d'intervalle:

Main Thread Id: 9
   12
   12
   12
   12
   12
   ... 

Ainsi, comme on le voit, OnDummyTimerFired est exécuté sur le thread Workers.

Non, complication supplémentaire - Si vous réduisez l'intervalle à 10 ms,

Main Thread Id: 9
   11
   13
   12
   22
   17
   ... 

En effet, si l'exécution précédente d'OnDummyTimerFired n'est pas effectuée lors du déclenchement suivant, .NET créerait un nouveau thread pour effectuer ce travail.

Pour compliquer encore les choses, "La classe System.Timers.Timer fournit un moyen simple de résoudre ce dilemme: elle expose une propriété SynchronizingObject publique. La définition de cette propriété sur une instance d'un Windows Form (ou un contrôle sur un Windows Form) garantira que le code de votre gestionnaire d'événements Elapsed s'exécute sur le même thread sur lequel le SynchronizingObject a été instancié. "

http://msdn.microsoft.com/en-us/magazine/cc164015.aspx#S2

Si l'événement écoulé prend plus de temps que l'intervalle, il créera un autre thread pour déclencher l'événement écoulé. Mais il existe une solution de contournement pour cela

static void timer_Elapsed(object sender, ElapsedEventArgs e)    
{     
   try
   {
      timer.Stop(); 
      Thread.Sleep(2000);        
      Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);    
   }
   finally
   {
     timer.Start();
   }
}