He estado leyendo la respuesta a unpregunta similar, pero todavía estoy un poco confundido ... Abel tuvo una gran respuesta, pero esta es la parte de la que no estoy seguro:

... declarar una variable volátil la hace volátil para cada acceso individual. Es imposible forzar este comportamiento de otra manera, por lo tanto, volátil no puede ser reemplazado por Enclavado. Esto es necesario en escenarios donde otras bibliotecas, interfaces o hardware pueden acceder a su variable y actualizarla en cualquier momento, o necesitan la versión más reciente.

HaceInterlocked garantizo la visibilidad de la operación atómica a todos los hilos, o todavía tengo que usar elvolatile palabra clave en el valor para garantizar la visibilidad del cambio?

Aquí está mi ejemplo:

volatile int value = 100000; // <-- do I need the volitile keyword
// ....

public void AnotherThreadMethod()
{
 while(Interlocked.Decrement(ref value)>0)
 {
  // do something
 }
}


public void AThreadMethod()
{
 while(value > 0)
 {
  // do something
 }
}

Actualizar:
Era un mal deporte y cambié el ejemplo original, así que aquí está de nuevo:

public class CountDownLatch
{
    private volatile int m_remain; // <--- do I need the volatile keyword here?
    private EventWaitHandle m_event;

    public CountDownLatch(int count)
    {
        Reset(count);
    }

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