I need to create a Thread-safe static variable in C# .Net

Question

ok, its a little more complicated than the question.

class A
{
   static int needsToBeThreadSafe = 0;

   public static void M1()
   {
     needsToBeThreadSa         


        

Answer 1

Sound like you need a Volatile member.

static volatile int needsToBeThreadSafe = 0;

Answer 2

class A
{
   static int needsToBeThreadSafe = 0;
   static object statObjLocker = new object();

   public static void M1()
   {
       lock(statObjLocker)
       {
          needsToBeThreadSafe = RandomNumber();
       }
   }

   public static void M2()
   {
       lock(statObjLocker)
       {
          print(needsToBeThreadSafe);
       }
   }
}

Answer 3

You have two choices: the easiest given your presented code is the volatile keyword. declare needsToBeThreadSafe as static volatile int and that will guarantee that any thread that references that variable will get the "latest" copy, and the variable won't be cached within your code.

That being said, if you want to more generally ensure that M1() and M2() execute "atomically" (or at least exclusively of each other), then you want to use a lock. The cleanest syntax is with a "lock block", like this:

private static object locker = new Object();

//..

public static void M1()
{
    lock(locker)
    {
        //..method body here
    }
}

public static void M2()
{
    lock(locker)
    {
        //..method body here
    }
}

As to which approach to take, that's up to you and should be determined by the code. If all you need is to ensure that a member assignment gets propagated to all threads and isn't cached, then the volatile keyword is simpler and will do the job just fine. If it's beyond that, you may want to go with the lock.

Answer 4

What you might be trying to ask about is the [ThreadStatic] attribute. If you want each thread that uses the class A to have its own separate value of needsToBeThreadSafe then you just need to decorate that field with the [ThreadStatic] attribute.

For more info refer to the MSDN documentation for ThreadStaticAttribute.

Answer 5

How About:

public static void M1()
{
    Interlocked.Exchange( ref needsToBeThreadSafe, RandomNumber() );
}

public static void M2()
{
    print( Interlocked.Read( ref needsToBeThreadSafe ) );
}

Answer 6

You can also use the ReaderWriterLockSlim, that is more efficient for multiple reads and less writes:

static int needsToBeThreadSafe = 0;
static System.Threading.ReaderWriterLockSlim rwl = new System.Threading.ReaderWriterLockSlim();

public static void M1()
{
    try
    {
        rwl.EnterWriteLock();
        needsToBeThreadSafe = RandomNumber();
    }
    finally
    {
        rwl.ExitWriteLock();
    }

}

public static void M2()
{
    try
    {
        rwl.EnterReadLock();
        print(needsToBeThreadSafe);
    }
    finally
    {
        rwl.ExitReadLock();
    }
}