C# : What if a static method is called from multiple threads?
In my Application I have a static method that is called from multiple threads at the same time. Is there any danger of my data being mixed up?
In my first attempt the method was not static and I was creating multiple instance of the class. In that case my data got mixed up somehow. I am not sure how this happens because it only happens sometimes. I am still debugging. But now the method is static on I have no problems so far. Maybe it's just luck. I don't know for sure.
Solution 1:
Variables declared inside methods (with the possible exception of "captured" variables) are isolated, so you won't get any inherent problems; however, if your static method accesses any shared state, all bets are off.
Examples of shared-state would be:
- static fields
- objects accessed from a common cache (non-serialized)
- data obtained via the input parameters (and state on those objects), if it is possible that multiple threads are touching the same object(s)
If you have shared state, you must either:
- take care not to mutate the state once it can be shared (better: use immutable objects to represent state, and take a snapshot of the state into a local variable - i.e. rather than reference
whatever.SomeDatarepeatedly, you readwhatever.SomeDataonce into a local variable, and then just use the variable - note that this only helps for immutable state!) - synchronize access to the data (all threads must synchronize) - either mutually exclusive or (more granular) reader/writer
Solution 2:
Yes, it's just luck. ;)
It doesn't matter if the method is static or not, what matters is if the data is static or not.
If each thread has its own separate instance of the class with its own set of data, there is no risk of data being mixed up. If the data is static, there is only one set of data, and all threads share the same data, so there is no way to not mix it up.
When your data in separate instances still gets mixed up, it's most likely because the data is not really separate.