C＃：在线程之间共享类成员

Question

我一直在开发多线程算法，并且对在C＃中的线程之间共享类成员有一些疑问。

假设我们有两个类，算法和处理器。 处理器具有主要方法DoWork和附加的AvaliableResources方法，有时会调用该方法来更改可用于处理的可用资源的数量。 Algorithm对象中的Run和UpdateResources方法由两个不同的线程调用，可能在不同的Core上工作。

难道 _processor变量将被存储在CPU的缓存，绝不会被上传到内存，并AvaliableResources将永远不会被调用，因为_processor第二个线程为空？

class Processor
{

    public void DoWork() { ...  }
    public void AvaliableResources(int x) { ... }
}

class Algorithm
{
    private Processor _processor;

    public void Run()
    {
        _processor = new Processor();
        _processor.DoWork();
        _processor = null;
    }

    public void UpdateResources(int x)
    {
        _processor?.AvaliableResources(x);
    }
}

如果存在同步问题 ，以下代码是否可以解决？

选择1

class Processor
{
    public void DoWork() { ... }
    public void UpdateResources(int x) { ... }
}

class Algorithm
{
    private volatile Processor _processor; // added volatile keyword

    public void Run()
    {
        _processor = new Processor();
        _processor.DoWork();
        _processor = null;
    }

    public void UpdateResources(int x)
    {
        _processor?.UpdateResources(x);
    }
}

选择2

class Processor
{
    public void DoWork() { ... }
    public void UpdateResources(int x) { ... }
}

class Algorithm
{
    private Processor _processor;

    public void Run()
    {
        _processor = new Processor();
        Thread.MemoryBarrier(); // Added memory barier
        _processor.DoWork();
        _processor = null;
    }

    public void UpdateResources(int x)
    {
        Thread.MemoryBarrier(); // Added memory barier
        _processor?.UpdateResources(x);
    }
}

编辑：正如您在评论中所建议的，请查看更好的解释代码：

    class Processor
    {
        private int resources = Environment.ProcessorCount;

        public void DoWork()
        {
            /*do some long running job using avaliable resources*/
        }

        public void UpdateResources(int x)
        {
            resources = x;
        }
    }

    class Algorithm
    {
        private volatile Processor _processor;

        public void Run()
        {
            _processor = new Processor();
            _processor.DoWork();
            _processor = null;
        }

        public void UpdateResources(int x)
        {
            _processor?.UpdateResources(x);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var algorithm = new Algorithm();
            var result = Task.Run(() => algorithm.Run());
            // The resources were required for other staff and are reduced
            algorithm.UpdateResources(1);
            // The resources are reassigned for the long running algorithm 
            algorithm.UpdateResources(10);
            // wait until the algorithm finishes
            result.Wait();
            // this update should have no effect as the Run method has finished and _processor is null
            algorithm.UpdateResources(10);
        }
    }

Answer 1

如果您想以这种方式访问​​_processor obj，则2替代方法是错误的。

无论如何，您应该在处理器中使用null，因为DoWork的运行和完成速度更快。 尝试在具有睡眠的第一个线程中查找同一秒，并检查是否执行了可用的线程。

您的代码没有提供足够的信息来建议正确的方法。

使用volatile关键字是正确的，但是如果Run快速可用，则永远不会调用

编辑

好的，很好的例子。 但是问题是在执行UpdateResources之前，运行完成的主要工作人员。

如果希望UpdateResources在等待之前执行两次，则插入新的方法，该方法在等待之后执行_processor= null 。 以某种方式使用此代码，每次在等待之前调用UpdateResources ，您的风险就是_processor为空。

在等待之前取决于您想要的东西