¿Es seguro usar un indicador booleano para detener la ejecución de un hilo en C#

Question

Mi preocupación principal es con el indicador booleano ... ¿es seguro usarlo sin ninguna sincronización? He leído en varios lugares que es atómico (incluida la documentación).

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

¿Es esta una forma segura de diseñar una tarea de esta manera? ¿Alguna sugerencia, mejoras, comentarios?

Nota: Escribí mi clase personalizada CountDownLatch en caso de que se esté preguntando de dónde estoy obteniendo.

Actualización:
Aquí es mi CountDownLatch también:

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

Será mejor que lo marca volatile sin embargo:

La palabra clave volátiles indica que un campo se puede modificar b y múltiple al mismo tiempo que ejecuta subprocesos. Los campos que se declaran volátiles no son sujetos a optimizaciones del compilador que asumen el acceso por un único hilo. Este garantiza que el valor más actualizado esté presente en el campo en todo momento.

Pero que cambiaría su bucle:

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

Como está en su puesto el 'algo de código' podría ejecutar cuando el hilo es detuvo (es decir, cuando la parada se llama.), Que es inesperado y puede ser incluso incorrecto.

Answer 2

Booleanos son atómica en C#: http://msdn.microsoft.com/en-us/library/aa691278(VS.71).aspx

Answer 3

Los booleanos son atómicos en C#, sin embargo, si quiere modificarlo en un hilo y leerlo en otro, deberá marcarlo como mínimo volátil. De lo contrario, el hilo de lectura solo puede leerlo una vez en un registro.

Answer 4

Por cierto, me he dado cuenta de esta parte del código:

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

Usted tendrá que desbloquear el subproceso de trabajo dos veces usando "startSignal.Set()" para el código dentro del bloque, mientras que se ejecute.

¿Esto es deliberado?