C#: Sharing a class member between threads

Question

I have been developing a multithreading algorithm and I have some doubts about sharing a class member between threads in C#.

Let's assume that we have two classes Algorithm and Processor. Processor has a main method DoWork and additional AvaliableResources method which is called occasionally to change the number of available resources for processing. The methods Run and UpdateResources in Algorithm object are invoked by two different threads, possibly working on different Cores.

Is it possible that _processor variable will be stored in CPU's cache and will never be uploaded to memory, and AvaliableResources would be never called because _processor is null for the second thread?

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

If there is a synchronization problem would the following code be a solution to for it?

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

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

Edit: As you have suggested in comments, please see better explained code:

    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

The 2 alternative is wrong if you want access to _processor obj in this way.

In any way, you should have null in processor because DoWork run and finish faster. Try to look for same second the first thread with sleep and check if available is executed.

Your code not provide enough information for suggest the right way.

Is right to use volatile keyword but if Run is fast available is not call never

EDIT

Ok, good example. But the problem is the main worker with Run finish before you UpdateResources is executed.

If you want that UpdateResources is execute twice before wait, you insert new method that execute _processor= null after wait. In some way every with this code, everytime you call UpdateResources before wait, your risk is _processor is null.

Depend on what you want before wait