Wie ein Worker-Thread richtig in C#

Question

Problemstellung

Ich habe einen Worker-Thread zu beenden, die im Grunde einen Ordner durchsucht, gehen in die Akten innerhalb und schlafen dann für eine Weile. Der Scanvorgang dauert 2-3 Sekunden, aber nicht viel mehr. Ich suche nach einer Möglichkeit, diesen Faden elegant zu stoppen.

Klärung: Ich möchte den Faden zu stoppen, während es Schlaf, ist und nicht, wenn esScannen ist. Das Problem ist jedoch, dass ich nicht weiß, was der aktuelle Status des Threads ist. Wenn es schläft, möchte ich es sofort verlassen. Wenn es scannt, möchte ich, dass es den Moment beendet, wenn es versucht zu blockieren.

Versuche einer Lösung

Zuerst war ich mit Schlaf und Interrupt. Dann habe ich herausgefunden, dass Interrupt den Schlaf nicht wirklich unterbricht - es funktioniert nur, wenn die Threads versuchen, in den Schlaf zu gehen.

Also wechselte ich auf Monitor Warten & Pulse. Dann habe ich herausgefunden, dass der Pulse nur funktioniert, wenn ich tatsächlich in der Wartestellung bin. So, jetzt habe ich einen Faden, der so aussieht:

while (m_shouldRun) 
{ 
    try 
    { 
     DoSomethingThatTakesSeveralSeconds(); 
     lock (this) 
     { 
      Monitor.Wait(this, 5000); 
     } 
    } 
    catch (ThreadInterruptedException) 
    { 
     m_shouldRun = false; 
    } 
} 

Und jetzt muss ich meine Stop Funktion Handwerk. Also begann ich mit:

public void Stop() 
{ 
    m_shouldRun = false; 
    lock (this) 
    { 
     Monitor.Pulse(this); 
    } 
    thread.Join(); 
} 

Aber das funktioniert nicht, weil ich während der Faden Werke pulsieren werden kann (während es nicht zu warten). So habe ich Interrupt:

public void Stop() 
{ 
    m_shouldRun = false; 
    thread.Interrupt(); 
    lock (this) 
    { 
     Monitor.Pulse(this); 
    } 
    thread.Join(); 
} 

Eine weitere Option ist die Verwendung:

public void Stop() 
{ 
    m_shouldRun = false; 
    while (!thread.Join(1000)) 
    { 
     lock (this) 
     { 
      Monitor.Pulse(this); 
     } 
    } 
} 

Die Frage

Was ist die bevorzugte Methode? Gibt es eine dritte Methode, die vorzuziehen ist?

Answer 1

Eine weitere Alternative ist Ereignisse zu verwenden:

private ManualResetEvent _event = new ManualResetEvent(false); 


public void Run() 
{ 
while (true) 
{ 
    DoSomethingThatTakesSeveralSeconds(); 
    if (_event.WaitOne(timeout)) 
     break; 
} 
} 

public void Stop() 
{ 
    _event.Set(); 
    thread.Join(); 
} 

Answer 2

Der Weg, um einen Faden elegant zu stoppen, ist, ihn von selbst zu beenden. Also könnten Sie innerhalb der Worker-Methode eine boolesche Variable haben, die prüft, ob wir unterbrechen wollen. Standardmäßig wird es auf false gesetzt und wenn Sie es vom Hauptthread auf true setzen, stoppt es einfach den Scanvorgang, indem es die Verarbeitungsschleife unterbricht.

Answer 3

Ich empfehle es einfach zu halten:

while (m_shouldRun) 
{ 
    DoSomethingThatTakesSeveralSeconds(); 
    for (int i = 0; i < 5; i++) // example: 5 seconds sleep 
    { 
     if (!m_shouldRun) 
      break; 
     Thread.Sleep(1000); 
    } 
} 

public void Stop() 
{ 
    m_shouldRun = false; 
    // maybe thread.Join(); 
} 

Dies hat folgende Vorteile:

• Es riecht nach busy waiting, aber es ist nicht. $ NUMBER_OF_SECONDS-Überprüfungen werden während der Wartephase durchgeführt, die nicht mit den Tausenden von Überprüfungen verglichen werden kann, die bei echtem Busy-Warten durchgeführt werden.
• Es ist einfach, was das Risiko von Fehlern in Multi-Thread-Code erheblich reduziert. Alle Ihre Stop Methode muss tun, um m_shouldRun zu false und (vielleicht) Thread.Join (wenn es notwendig ist, den Thread zu beenden, bevor Stop übrig ist) zu setzen.Es sind keine Synchronisationsprimitiven erforderlich (außer dass m_shouldRun als flüchtig markiert wird).

Answer 4

ich mit separat Planung der Aufgabe kam.

using System; 
using System.Threading; 

namespace ProjectEuler 
{ 
    class Program 
    { 
     //const double cycleIntervalMilliseconds = 10 * 60 * 1000; 
     const double cycleIntervalMilliseconds = 5 * 1000; 
     static readonly System.Timers.Timer scanTimer = 
      new System.Timers.Timer(cycleIntervalMilliseconds); 
     static bool scanningEnabled = true; 
     static readonly ManualResetEvent scanFinished = 
      new ManualResetEvent(true); 

     static void Main(string[] args) 
     { 
      scanTimer.Elapsed += 
       new System.Timers.ElapsedEventHandler(scanTimer_Elapsed); 
      scanTimer.Enabled = true; 

      Console.ReadLine(); 
      scanningEnabled = false; 
      scanFinished.WaitOne(); 
     } 

     static void scanTimer_Elapsed(object sender, 
      System.Timers.ElapsedEventArgs e) 
     { 
      scanFinished.Reset(); 
      scanTimer.Enabled = false; 

      if (scanningEnabled) 
      { 
       try 
       { 
        Console.WriteLine("Processing"); 
        Thread.Sleep(5000); 
        Console.WriteLine("Finished"); 
       } 
       finally 
       { 
        scanTimer.Enabled = scanningEnabled; 
        scanFinished.Set(); 
       } 
      } 
     } 
    } 
}