Are static methods thread safe

I have a static timer class which will be called by ANY webpage to calculate how long each page has taken to be constructed.

My question is are Static classes thread safe? In my example will concurrent users cause a problem with my start and stop times? e.g a different threads overwriting my start and stop values.

public static class Timer
    private static DateTime _startTime;
    private static DateTime _stopTime;    

    /// <summary>
    /// Gets the amount of time taken in milliseconds
    /// </summary>
    /// <returns></returns>
    public static decimal Duration()
        TimeSpan duration =  _stopTime - _startTime;
        return duration.Milliseconds;

    public static void Start()
        _startTime = DateTime.Now;

    public static void Stop()
        _stopTime = DateTime.Now;

Should this class be a non-static class?

(This class will called from the masterpage.)


Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

Static methods aren’t inherently thread-safe. They’re treated no differently by the CLR than instance methods. The difference is that one should generally try to make them thread-safe. (I can’t think of any .NET BCL static methods which aren’t thread-safe.) Instance methods are often not thread-safe because the typical pattern is to create an object and use it repeatedly from one thread, and if it does have to be used from multiple threads, the co-ordination involved includes making sure that the object is used safely. In very many cases that’s more appropriate to do in the co-ordinating code than in the object itself. (Usually you want to make whole sequences of operations effectively atomic – something which can’t be done within the object.)

Your Timer class is most definitely not thread-safe: two threads can stomp on each other’s data with ease, and there’s nothing to stop a thread from using “stale” data when calculating the duration.

Use the Stopwatch class instead – that’s what it’s there for. Admittedly if you want to use one instance from multiple threads you’ll need to take the normal steps to ensure safety, but you’ll be in a much better position in general. Admittedly Stopwatch is far from perfect too – see this question and the comment below for more details – but it is at least what the type is designed for. (Who knows, it may be fixed some time…)

Method 2

There is a good discussion here that focuses more on the mechanisms and reasons for why your example is not thread-safe.

To summarize, first, your static variables will be shared. If you could make them local variables, even though they are local to a static method, they would still get their own stack frame, and thus, be thread-safe. Also, if you otherwise protect your static variables (ie, locks and/or other multi-threaded programming techniques mentioned by others in this thread) you could also make your sample static class thread-safe.

Second, because your example does not take in external variable instances which you modify or whose state might get acted upon by another thread, your example is thread-safe in that regard as well.

Method 3

Your timer class is definitely not thread-safe. You should create a normal class and instantiate it every time you need to measure the time:

Timer timer = new Timer();


decimal duration = timer.Duration();

Better still, there is a built-in .NET class that does exactly that:

Stopwatch sw = Stopwatch.StartNew();


TimeSpan duration = sw.Elapsed;

Method 4

Yes, you’re right, the static members / accessors on this class will cause them to be overwritten by different users.

This is why you have instances and non-static members.

All methods was sourced from or, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0

0 0 votes
Article Rating
Notify of

Inline Feedbacks
View all comments
Would love your thoughts, please comment.x