Vergehen C # -Timer in einem separaten Thread?

Läuft ein System.Timers.Timer in einem anderen Thread als dem Thread ab, der ihn erstellt hat?

Nehmen wir an, ich habe eine Klasse mit einem Timer, der alle 5 Sekunden ausgelöst wird. Wenn der Timer ausgelöst wird, wird in der abgelaufenen Methode ein Objekt geändert. Nehmen wir an, das Ändern dieses Objekts dauert lange, beispielsweise 10 Sekunden. Ist es möglich, dass ich in diesem Szenario auf Thread-Kollisionen stoße?

Für System.Timers.Timer :

Siehe Brian Gideons Antwort unten

Für System.Threading.Timer :

In der MSDN-Dokumentation zu Timern heißt es:

Die System.Threading.Timer-Klasse führt Rückrufe für einen ThreadPool-Thread durch und verwendet das Ereignismodell überhaupt nicht.

Der Timer läuft also tatsächlich auf einem anderen Thread ab.

Es hängt davon ab, ob. Der System.Timers.Timerhat zwei Betriebsarten.

Wenn SynchronizingObjecteine ISynchronizeInvokeInstanz festgelegt ist, wird das ElapsedEreignis auf dem Thread ausgeführt, auf dem sich das Synchronisierungsobjekt befindet. Normalerweise sind diese ISynchronizeInvokeInstanzen nichts anderes als alte Controlund FormInstanzen, mit denen wir alle vertraut sind. In diesem Fall wird das ElapsedEreignis im UI-Thread aufgerufen und verhält sich ähnlich wie das System.Windows.Forms.Timer. Ansonsten hängt es wirklich von der spezifischen ISynchronizeInvokeInstanz ab, die verwendet wurde.

Wenn SynchronizingObjectnull ist, wird das ElapsedEreignis in einem ThreadPoolThread aufgerufen und verhält sich ähnlich wie das System.Threading.Timer. Tatsächlich verwendet es einen System.Threading.TimerBlick hinter die Kulissen und führt den Marshalling-Vorgang aus, nachdem es bei Bedarf den Timer-Rückruf erhalten hat.

Jedes verstrichene Ereignis wird im selben Thread ausgelöst, es sei denn, ein vorheriges verstrichenes Ereignis wird noch ausgeführt.

So erledigt es die Kollision für Sie

Versuchen Sie dies in eine Konsole zu setzen

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

Sie werden so etwas bekommen

10
6
12
6
12

Dabei ist 10 der aufrufende Thread und 6 und 12 werden aus dem abgelaufenen bg-Ereignis ausgelöst. Wenn Sie den Thread.Sleep (2000) entfernen; Sie werden so etwas bekommen

10
6
6
6
6

Da gibt es keine Kollisionen.

Aber das lässt dich immer noch mit einem Problem zurück. Wenn Sie das Ereignis alle 5 Sekunden auslösen und die Bearbeitung 10 Sekunden dauert, benötigen Sie eine Sperre, um einige Änderungen zu überspringen.

Für System.Timers.Timer in einem separaten Thread, wenn SynchronizingObject nicht festgelegt ist.

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

Ausgabe, die Sie sehen würden, wenn DummyTimer im Intervall von 5 Sekunden ausgelöst würde:

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

Wie zu sehen ist, wird OnDummyTimerFired im Workers-Thread ausgeführt.

Nein, weitere Komplikationen - Wenn Sie das Intervall auf 10 ms reduzieren,

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

Dies liegt daran, dass .NET einen neuen Thread für diesen Job erstellen würde, wenn die vorherige Ausführung von OnDummyTimerFired beim nächsten Häkchen nicht erfolgt.

Erschwerend kommt hinzu: "Die System.Timers.Timer-Klasse bietet eine einfache Möglichkeit, dieses Dilemma zu lösen. Sie macht eine öffentliche SynchronizingObject-Eigenschaft verfügbar. Durch Festlegen dieser Eigenschaft für eine Instanz eines Windows Form (oder eines Steuerelements in einem Windows Form) wird dies sichergestellt dass der Code in Ihrem Elapsed-Ereignishandler auf demselben Thread ausgeführt wird, auf dem das SynchronizingObject instanziiert wurde. "

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

Wenn das abgelaufene Ereignis länger als das Intervall dauert, wird ein weiterer Thread erstellt, um das abgelaufene Ereignis auszulösen. Dafür gibt es jedoch eine Problemumgehung

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