What Makes a Method Thread-safe What are the rules

Question

Are there overall rules guidelines for what makes a method thread-safe  I understand that there are probably a million one-off situations  but what about in general  Is it this simple    If a method only accesses local variables  it s thread safe    Is that it  Does that apply for static methods as well   One answer  provided by  Cybis  was       Local variables cannot be shared among threads because each thread gets its own stack    Is that the case for static methods as well   If a method is passed a reference object  does that break thread safety  I ve done some research  and there is a lot out there about certain cases  but I was hoping to be able to define  by using just a few rules  guidelines to follow to make sure a method is thread safe   So  I guess my ultimate question is   Is there a short list of rules that define a thread-safe method  If so  what are they    EDIT A lot of good points have been made here  I think the real answer to this question is   There are no simple rules to ensure thread safety   Cool  Fine  But in general I think the accepted answer provides a good  short summary  There are always exceptions  So be it  I can live with that

User · Answer

If a method only accesses local variables, it's thread safe. Is that it?

Absolultely not. You can write a program with only a single local variable accessed from a single thread that is nevertheless not threadsafe:

https://stackoverflow.com/a/8883117/88656

Does that apply for static methods as well?

Absolutely not.

One answer, provided by @Cybis, was: "Local variables cannot be shared among threads because each thread gets its own stack."

Absolutely not. The distinguishing characteristic of a local variable is that it is only visible from within the local scope, not that it is allocated on the temporary pool. It is perfectly legal and possible to access the same local variable from two different threads. You can do so by using anonymous methods, lambdas, iterator blocks or async methods.

Is that the case for static methods as well?

Absolutely not.

If a method is passed a reference object, does that break thread safety?

Maybe.

I've done some research, and there is a lot out there about certain cases, but I was hoping to be able to define, by using just a few rules, guidelines to follow to make sure a method is thread safe.

You are going to have to learn to live with disappointment. This is a very difficult subject.

So, I guess my ultimate question is: "Is there a short list of rules that define a thread-safe method?

Nope. As you saw from my example earlier an empty method can be non-thread-safe. You might as well ask "is there a short list of rules that ensures a method is correct". No, there is not. Thread safety is nothing more than an extremely complicated kind of correctness.

Moreover, the fact that you are asking the question indicates your fundamental misunderstanding about thread safety. Thread safety is a global, not a local property of a program. The reason why it is so hard to get right is because you must have a complete knowledge of the threading behaviour of the entire program in order to ensure its safety.

Again, look at my example: every method is trivial. It is the way that the methods interact with each other at a "global" level that makes the program deadlock. You can't look at every method and check it off as "safe" and then expect that the whole program is safe, any more than you can conclude that because your house is made of 100% non-hollow bricks that the house is also non-hollow. The hollowness of a house is a global property of the whole thing, not an aggregate of the properties of its parts.

User · Answer

There is no hard and fast rule   Here are some rules to make code thread safe in  NET and why these are not good rules    Function and all functions it calls must be pure  no side effects  and use local variables   Although this will make your code thread-safe  there is also very little amount of interesting things you can do with this restriction in  NET  Every function that operates on a common object must lock on a common thing   All locks must be done in same order   This will make the code thread safe  but it will be incredibly slow  and you might as well not use multiple threads        There is no rule that makes the code thread safe  the only thing you can do is make sure that your code will work no matter how many times is it being actively executed  each thread can be interrupted at any point  with each thread being in its own state location  and this for each function  static or otherwise  that is accessing common objects

User · Answer

If a method  instance or static  only references variables scoped within that method then it is thread safe because each thread has its own stack   In this instance  multiple threads could call ThreadSafeMethod concurrently without issue   public class Thing       public int ThreadSafeMethod string parameter1                int number     each thread will have its own variable for number          number   parameter1 Length          return number            This is also true if the method calls other class method which only reference locally scoped variables   public class Thing       public int ThreadSafeMethod string parameter1                int number          number   this GetLength parameter1           return number             private int GetLength string value                int length   value Length          return length            If a method accesses any  object state  properties or fields  instance or static  then you need to use locks to ensure that the values are not modified by a different thread   public class Thing       private string someValue     all threads will read and write to this same field value      public int NonThreadSafeMethod string parameter1                this someValue   parameter1           int number              Since access to someValue is not synchronised by the class  a separate thread            could have changed its value between this thread setting its value at the start             of the method and this line reading its value          number   this someValue Length          return number            You should be aware that any parameters passed in to the method which are not either a struct or immutable could be mutated by another thread outside the scope of the method   To ensure proper concurrency you need to use locking   for further information see lock statement C  reference and ReadWriterLockSlim    lock is mostly useful for providing one at a time functionality   ReadWriterLockSlim is useful if you need multiple readers and single writers

User · Answer

It must be synchronized  using an object lock  stateless  or immutable   link  http   docs oracle com javase tutorial essential concurrency immutable html

[c#] What Makes a Method Thread-safe? What are the rules?

Examples related to c#

Examples related to thread-safety