Ich habe die Antwort auf a gelesenähnliche Frage, aber ich bin immer noch ein bisschen verwirrt ... Abel hatte eine großartige Antwort, aber dies ist der Teil, bei dem ich mir nicht sicher bin:

... wenn eine Variable als flüchtig deklariert wird, wird sie für jeden einzelnen Zugriff flüchtig. Es ist unmöglich, dieses Verhalten auf andere Weise zu erzwingen, daher kann Volatile nicht durch Interlocked ersetzt werden. Dies ist in Szenarien erforderlich, in denen andere Bibliotheken, Schnittstellen oder Hardware auf Ihre Variable zugreifen und diese jederzeit aktualisieren können oder die neueste Version benötigen.

TutInterlocked Sichtbarkeit der atomaren Operation für alle Threads garantieren, oder muss ich noch die verwendenvolatile Schlüsselwort auf den Wert, um die Sichtbarkeit der Änderung zu gewährleisten?

Hier ist mein Beispiel:

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

Aktualisieren:
Ich war ein schlechter Sport und habe das ursprüngliche Beispiel geändert, also hier ist es wieder:

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