What is the threading class if I just want to test and set a flag in a threadsafe manner?

Question

I just want to do a simple, though thread-safe, boolean test (and set) so:

if(myBoolean==false)   //should not lock/wait!
{ 
     myBoolean=true;
     .....
}
else
{
     ....
}

I considered the following (although possibly incorrectly, so please correct me where I misunderstood)

• using the Lock { if(myBoolean)... } construct seems like a overkill way to do it. And, it also locks the thread while it waits for the lock to become free. I don't want this.
• The AutoResetEvent class does have a concept of a boolean state, but it is used to signal another thread which is waiting. So not relevant in my case
• Semaphore class has a notion of a reference count (probably to throttle the amount of access to a resource?). So probably not what I'm after.
• Mutex class. As far as I understood, this is the same principal as the Lock primitive

Anyone have an idea what is the class/construct to do this in an efficient manner?

Answer 1

Your question is somewhat ambiguous, but you're probably looking for the Interlocked class.

EDIT: You're looking for Interlocked.CompareExchange.

Answer 2

Consider Interlocked.CompareExchange.

Answer 3

To have a thread safe test and set operation the code have to block other threads. To avoid locking uneccesary, you can use the test-and-test-and-set pattern:

if (something) {
   lock(_sync) {
      if (something) {
         something = false;
         ...
      }
   }
}

The second test is needed to be sure that some other thread didn't change the value between the first test and the lock.

Answer 4

The answer (Intelocked.CompareExchange) was already given, but here's my usage example:

private int _isDisposing;

public bool IsDisposing
{
    get
    {
        return this._isDisposing != 0;
    }
}

public void Dispose()
{
    // Side note: I may want to `return` instead of `throw`
    if (Interlocked.CompareExchange(ref _isDisposing, 1, 0) != 0)
        throw new InvalidOperationException("Dispose was recursively called.");

    try
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    finally
    {
        _isDisposing = 0;
    }
}