Eu tenho lido a resposta para umpergunta semelhante, mas ainda estou um pouco confuso ... Abel teve uma ótima resposta, mas esta é a parte da qual não tenho certeza:

... declarar uma variável volátil torna-a volátil para todos os acessos. É impossível forçar esse comportamento de qualquer outra maneira, portanto, o volátil não pode ser substituído por Intertravado. Isso é necessário em cenários em que outras bibliotecas, interfaces ou hardware podem acessar sua variável e atualizá-la a qualquer momento ou precisam da versão mais recente.

FazInterlocked garantir a visibilidade da operação atômica para todos os encadeamentos ou ainda preciso usar ovolatile palavra-chave no valor para garantir a visibilidade da alteração?

Aqui está o meu exemplo:

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

Atualizar:
Eu era um esporte ruim e mudei o exemplo original, então aqui está novamente:

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