I timer C # trascorrono in un thread separato?

Un System.Timers.Timer trascorre su un thread separato rispetto al thread che lo ha creato?

Diciamo che ho una lezione con un timer che si attiva ogni 5 secondi. Quando il timer si attiva, nel metodo trascorso, alcuni oggetti vengono modificati. Diciamo che ci vuole molto tempo per modificare questo oggetto, come 10 secondi. È possibile che incorrerò in collisioni di thread in questo scenario?

Per System.Timers.Timer :

Vedi la risposta di Brian Gideon di seguito

Per System.Threading.Timer :

La documentazione di MSDN sui timer afferma:

La classe System.Threading.Timer effettua callback su un thread ThreadPool e non utilizza affatto il modello di eventi.

Quindi effettivamente il timer scade su un thread diverso.

Dipende. Il System.Timers.Timerha due modi di funzionamento.

Se SynchronizingObjectè impostato su ISynchronizeInvokeun'istanza, l' Elapsedevento verrà eseguito sul thread che ospita l'oggetto di sincronizzazione. Di solito questi ISynchronizeInvokecasi non sono altro che semplici vecchi Controle Formcasi che tutti conosciamo. Quindi in quel caso l' Elapsedevento viene richiamato sul thread dell'interfaccia utente e si comporta in modo simile al System.Windows.Forms.Timer. In caso contrario, dipende davvero dall'istanza specifica ISynchronizeInvokeutilizzata.

Se SynchronizingObjectè null, l' Elapsedevento viene richiamato su un ThreadPoolthread e si comporta in modo simile al System.Threading.Timer. In effetti, utilizza effettivamente un System.Threading.Timerdietro le quinte ed esegue l'operazione di marshalling dopo aver ricevuto il callback del timer, se necessario.

Ogni evento trascorso verrà attivato nello stesso thread a meno che un Elapsed precedente non sia ancora in esecuzione.

Quindi gestisce la collisione per te

prova a metterlo in una 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);
}

otterrai qualcosa di simile

10
6
12
6
12

dove 10 è il thread chiamante e 6 e 12 si attivano dall'evento trascorso bg. Se rimuovi Thread.Sleep (2000); otterrai qualcosa di simile

10
6
6
6
6

Poiché non ci sono collisioni.

Ma questo ti lascia ancora con un problema. se stai attivando l'evento ogni 5 secondi e ci vogliono 10 secondi per modificare, hai bisogno di un blocco per saltare alcune modifiche.

Per System.Timers.Timer, su thread separato, se SynchronizingObject non è impostato.

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

Output che vedresti se DummyTimer si attivasse con un intervallo di 5 secondi:

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

Quindi, come visto, OnDummyTimerFired viene eseguito sul thread Workers.

No, ulteriore complicazione: se riduci l'intervallo a dire 10 ms,

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

Questo perché se l'esecuzione precedente di OnDummyTimerFired non viene eseguita quando viene attivato il tick successivo, .NET creerebbe un nuovo thread per eseguire questo lavoro.

A complicare ulteriormente le cose, "La classe System.Timers.Timer fornisce un modo semplice per affrontare questo dilemma: espone una proprietà SynchronizingObject pubblica. L'impostazione di questa proprietà su un'istanza di un Windows Form (o un controllo su un Windows Form) garantirà che il codice nel gestore dell'evento Elapsed venga eseguito sullo stesso thread in cui è stata creata l'istanza di SynchronizingObject. "

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

Se l'evento trascorso richiede più tempo dell'intervallo, creerà un altro thread per generare l'evento trascorso. Ma c'è una soluzione alternativa per questo

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