使用布尔标志来阻止线程在C#中运行是否安全？

Question

我主要关心的是布尔标志......没有任何同步就可以安全地使用它吗？我在几个地方读到它是原子的(包括文档).

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

这是以这种方式设计任务的安全方式吗？有什么建议,改进,评论吗？

注意:我写了我的自定义CountDownLatch类,以防你想知道我从哪里得到它.

更新:
这也是我的CountDownLatch:

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

你最好标记它volatile:

volatile关键字指示可能由多个并发执行的线程修改字段.声明为volatile的字段不受编译器优化的约束,这些优化假定由单个线程进行访问.这可确保始终在字段中显示最新值.

但我会改变你的循环:

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

正如在你的帖子中那样,"某些代码"可能在线程停止时(即调用Stop时)执行,这是意外的,甚至可能是不正确的.

Answer 2

布尔值在C＃中是原子的，但是，如果要在一个线程中修改它并在另一个线程中读取它，则至少需要将其标记为volatile。否则，读取线程实际上只能将其一次读取到一个寄存器中。