Question

I have the following scenario in my code (C# .NET 4):

I have a boolean variable that is initialized to false:

bool b = false;

now I am instantiating number of threads, that each one of them need to read the value of b. the first thread to read b – should change its value to true (and do some logic…), and the others should do nothing. Do I need to use sync mechanism for ‘b’ while reading its value, or can I lock it only while setting its value to true?
This should boost my performance, but I am wondering id its safe..

Answer 1

So the requirements are:

• multiple threads read a single bool variable
• if a thread sees a false value it should change it to true and perform additional work
• if a thread sees a true value then nothing else should happen
• only one thread should be able to change the value and perform the additional work

So the code would look like:

public class Example
{
  private bool b = false;

  public void DoSomething()
  {
    if (!b)
    {
      b = true;
      DoExtraStuff();
    }
  }
}

This, of course, is not safe if there are multiple threads executing DoSomething and the intention is that DoExtraStuff should only be executed once. The problem is that the threads will race on the read and write of b.

You really need to make the read and write to b atomic. This can be done using the lock keyword.

public class Example
{
  private bool b = false;
  private object locker = new object();

  public void DoSomething()
  {
    bool trigger = false;
    lock (locker)
    {
      if (!b)
      {
        b = true;
        trigger = true;
      }
    }

    if (trigger)
    {
      DoExtraStuff();
    }
  }
}

There is an alternate pattern using a CAS operation via Interlocked.CompareExhange. Unfortunately, there is no overload that accepts a bool, but if you are willing to change that bool to an int the following would also work.

public class Example
{
  private int b = 0;

  public void DoSomething()
  {
    if (Interlocked.CompareExchange(ref b, 0, 1) == 0)
    {
      DoExtraStuff();
    }
  }
}