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

Question

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

假设我们有两个类算法和处理器。处理器有一个 main 方法 DoWork 和附加的 AvaliableResources 方法，该方法偶尔调用以更改可用于处理的资源的数量。 Algorithm 对象中的方法 Run 和 UpdateResources 由两个不同的线程调用，可能在不同的核心上工作。

是否有可能 _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);
    }
}

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

    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

如果您想访问，则 2 选择是错误的 _processor obj 这种方式。

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

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

使用 volatile 关键字是正确的，但如果 R​​un 快速可用则不调用 never

编辑

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

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

在等待之前取决于你想要什么