What is a best approach to make a function or set of statements thread safe in C#?

Question

What is a best approach to make a function or set of statements thread safe in C#?

Answer 1

Don't use shared read/write state when possible. Go with immutable types.

Answer 2

There's a lot to understand when learning what "thread safe" means and all the issues that are introduced (synchronization, etc).

I'd recommend reading through this page in order to get a better feel for what you're asking: Threading in C#. It gives a pretty comprehensive overview of the subject, which sounds like it could be pretty helpful.

And Mehrdad's absolutely right -- go with immutable types if you can help it.

Answer 3

Use lock statement around shared state variables. Once you ensured thread safety, run code through code profiler to find bottlenecks and optimize those places with more advanced multi-threading constructs.

Answer 4

Take a look at the C# lock statement. Read Jon Skeet's article on multi threading in .net.

Answer 5

It depends on what you're trying to accomplish. If you want to make sure that in any given time only one thread would run a specific code use lock or Monitor:

public void Func(...)
{
   lock(syncObject)
   {
      // only one thread can enter this code
   }
}

On the other hand you want multiple threads to run the same code but do not want them to cause race conditions by changing the same point in memory don't write to static/shared objects which can be reached by multiple at the same time.

BTW - If you want to create a static object that would be shared only within a single thread use the ThreadStatic attribute (http://msdn.microsoft.com/en-us/library/system.threadstaticattribute%28VS.71%29.aspx).

Answer 6

The best approach will vary depending on your exact problem at hand.

The simplest approach in C# is to "lock" resources shared by multiple threads using a lock statement. This creates a block of code which can only be accessed by one thread at a time: the one which has obtained the "lock" object. For example, this property is thread safe using the lock syntax:

public class MyClass
{
    private int _myValue;

    public int MyProperty
    {
        get
        {
            lock(this)
            {
                return _myValue;
            }
        }
        set
        {
            lock(this)
            {
                _myValue = value;
            }
        }
    }
}

A thread aquires the lock at the start of the block and only releases the lock at the end of the block. If the lock is not available, the thread will wait until the lock is available. Obviously, access to the private variable within the class is not thread-safe, so all threads must access the value through the property to be safe.

This is by far the simplest way for threads to have safe access to shared data, however it only touches the tip of the iceberg of techniques for threading.

Answer 7

Write the function in such a way that:

1. It does not modify its parameters in any way
2. It does not access any state outside of its local variables.

Otherwise, race conditions MAY occur. The code must be thoroughly examined for such conditions and appropriate thread synchronization must be implemented (locks, etc...). Writing code that does not require synchronization is the best way to make it thread-safe. Of course, this is often not possible - but should be the first option considered in most situations.