Ist es sicher, ein boolesches Flag zu verwenden, um die Ausführung eines Threads in C#

Question

zu stoppen? Mein Hauptanliegen ist das boolesche Flag ... ist es sicher, es ohne Synchronisation zu benutzen? Ich habe an mehreren Stellen gelesen, dass es atomar ist (einschließlich der Dokumentation).

class MyTask 
{ 
    private ManualResetEvent startSignal; 
    private CountDownLatch latch; 
    private bool running; 

    MyTask(CountDownLatch latch) 
    { 
     running = false; 
     this.latch = latch; 
     startSignal = new ManualResetEvent(false); 
    } 

    // A method which runs in a thread 
    public void Run() 
    { 
     startSignal.WaitOne(); 
     while(running) 
     { 
      startSignal.WaitOne(); 
      //... some code 
     } 
     latch.Signal(); 
    } 

    public void Stop() 
    { 
     running = false; 
     startSignal.Set(); 
    } 

    public void Start() 
    { 
     running = true; 
     startSignal.Set(); 
    } 

    public void Pause() 
    { 
     startSignal.Reset(); 
    } 

    public void Resume() 
    { 
     startSignal.Set(); 
    } 
} 

Ist dies ein sicherer Weg, um eine Aufgabe auf diese Weise zu entwerfen? Irgendwelche Vorschläge, Verbesserungen, Kommentare?

Hinweis: Ich schrieb meine benutzerdefinierte CountDownLatch Klasse für den Fall, dass Sie sich fragen, woher ich es bekomme.

Update:
Hier ist meine CountDownLatch auch:

public class CountDownLatch 
{ 
    private volatile int m_remain; 
    private EventWaitHandle m_event; 

    public CountDownLatch (int count) 
    { 
     if (count < 0) 
      throw new ArgumentOutOfRangeException(); 
     m_remain = count; 
     m_event = new ManualResetEvent(false); 
     if (m_remain == 0) 
     { 
      m_event.Set(); 
     } 
    } 

    public void Signal() 
    { 
     // The last thread to signal also sets the event. 
     if (Interlocked.Decrement(ref m_remain) == 0) 
      m_event.Set(); 
    } 

    public void Wait() 
    { 
     m_event.WaitOne(); 
    } 
} 

Answer 1

Sie besser es volatile obwohl markieren:

Das Schlüsselwort volatile zeigt an, dass ein Feld möglicherweise geändert wurde b y mehrere gleichzeitig Threads ausgeführt. Die Felder , die als flüchtig deklariert sind, sind nicht , abhängig von Compiler-Optimierungen, die Zugriff von einem einzelnen Thread annehmen. Diese stellt sicher, dass immer der aktuellste Wert im Feld vorhanden ist.

Aber ich würde Ihre Schleife ändern:

startSignal.WaitOne(); 
    while(running) 
    { 
     //... some code 
     startSignal.WaitOne(); 
    } 

Wie es in Ihrem Beitrag die ‚einige Code‘ ist möglicherweise ausgeführt wird, wenn der Faden gestoppt ist (dh wenn Stopp aufgerufen wird.), Welche unerwartet und möglicherweise sogar falsch.

Answer 2

Boolesche Werte sind atomar in C#: http://msdn.microsoft.com/en-us/library/aa691278(VS.71).aspx

Answer 3

Boolesche Werte sind in C# atomar. Wenn Sie sie jedoch in einem Thread ändern und in einem anderen lesen möchten, müssen Sie sie mindestens als flüchtig markieren. Andernfalls liest der Lese-Thread es tatsächlich nur einmal in ein Register ein.

Answer 4

BTW, ich habe gerade bemerkt, diesen Teil des Codes:

// A method which runs in a thread 
    public void Run() 
    { 
     startSignal.WaitOne(); 
     while(running) 
     { 
      startSignal.WaitOne(); 
      //... some code 
     } 
     latch.Signal(); 
    } 

Sie müssen den Arbeiter-Thread zweimal mit „startSignal.Set()“ für den Code innerhalb des während des Blockes entsperren auszuführen.

Ist das beabsichtigt?