What Makes a Method Thread-safe? What are the rules?

by

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.

More Related Contents:

  1. Create Dynamic Threads in c# [closed]
  2. Collection was modified; enumeration operation may not execute
  3. Automating the InvokeRequired code pattern
  4. What does a lock statement do under the hood?
  5. What’s the best way of implementing a thread-safe Dictionary?
  6. Concurrent HashSet in .NET Framework?
  7. System.Lazy with different thread-safety mode
  8. Are C# arrays thread safe?
  9. How to create a task (TPL) running a STA thread?
  10. Why we need Thread.MemoryBarrier()?
  11. Thread-safe List property
  12. C# thread safety with get/set
  13. Why do I need a memory barrier?
  14. Entity Framework Thread Safety
  15. Thread safety of a Dictionary with multiple concurrent readers and no writers
  16. Is a reference assignment threadsafe?
  17. Are IEnumerable Linq methods thread-safe?
  18. Do I need to lock or mark as volatile when accessing a simple boolean flag in C#?
  19. Async threadsafe Get from MemoryCache
  20. thread with multiple parameters
  21. Event handlers not thread safe? [duplicate]
  22. Are you there, asynchronously written value?
  23. Is this use of Parallel.ForEach() thread safe?
  24. System.InvalidOperationException: Collection was modified
  25. Thread Safe Properties in C#
  26. Is Stopwatch.ElapsedTicks threadsafe?
  27. C# and thread-safety of a bool
  28. Is it ok to await the same task from multiple threads – is await thread safe?
  29. Is int? thread safe?
  30. Writing to file in a thread safe manner

Leave a Comment