Race Condition with Static Class?

Question

Let's say I have a static class with a static method.

Multiple threads can call this static method concurrently.

Is there a potential for a race condition under these circumstances:

a - if the method depends only on local variables
b - if the method depends on local variables and member fields

Answer 1

Let's say I have a static class with a static method. Multiple threads can call this static method concurrently.

OK.

Is there a potential for a race condition under these circumstances: a - if the method depends only on local variables

Yes, there are potential race conditions.

b - if the method depends on local variables and member fields

Yes, there are potential race conditions.

The answers to (a) and (b) are a consequence of a more general rule, namely, there is always the potential for race conditions any time you call any method from multiple threads. For example, this program deadlocks:

class MyClass
{
  static MyClass() 
  {
    // Let's run the initialization on another thread!
    var thread = new System.Threading.Thread(Initialize);
    thread.Start();
    thread.Join();
  }

  static void Initialize() 
  { }

  static void Main() 
  { }
}

It has no fields, two methods that do absolutely nothing, and a single local variable that is only accessed on a single thread. And nevertheless, it immediately and consistently deadlocks. (Do you see why? See http://ericlippert.com/2013/01/31/the-no-lock-deadlock/ for more on this program.)

It sounds like you are looking for a guarantee that your program is threadsafe if your static methods do not access fields. There is no such guarantee. Your program is threadsafe if and only if you write it to be threadsafe.

Answer 2

First off, a method is simply a piece of code residing at an address. Each thread calling a method will have a copy of that method and its local variables on its own private stack. So in case a, provided there are no other catches, it should be thread-safe.

Case b depends on a lot of factors:

• are you actually accessing those member variables?
• how are you accessing them: only reads, reads + writes, etc.
• what kind of member variables: data structures, single values.
• do you have any synchronization in place?
• etc.

Generally though, assuming you do access the class members, it should not be considered thread-safe.

Answer 3

A - No. Race conditions only occur when static methods are attempting to access a shared resource. The local variable will be unique to each thread calling the method.

B - Yes. Those static members will be shared by all of the threads calling that method.