Race Conditions in Threading C#

The reason for this is that the operating system decides which thread gets executed first. And the order in which we start the threads is not all that important. So thread that is given least priority by the operating system gets executed last.

The Solution

C# provide number of ways to avoid race conditions depending on the type of application you are writing. But the most common method that works in any condition is using Wait Handles and Signaling. In the above example we will try to ensure that the first thread is the last one that writes value to result variable.

The process is quite simple let all threads are started at the same time. But the first thread is forced to wait till second and third thread signal that they are done.

Similarly the main thread is forced to wait till the first thread completes. This ensures that the Console.WriteLine() is not called before the other threads finish their work.

using System;
using System.Threading;
namespace RaceCondition
{
class Akshay
{
int result = 0;
AutoResetEvent event1 = new AutoResetEvent(false);
AutoResetEvent event2 = new AutoResetEvent(false);
AutoResetEvent event3 = new AutoResetEvent(false);
void Work1()
{
WaitHandle.WaitAll(new WaitHandle[] { event2, event3 });
result = 1;
event1.Set();
}
void Work2() { result = 2; event2.Set(); }
void Work3() { result = 3; event3.Set(); }
static void Main(string[] args)
{
Akshay a = new Akshay();
Thread worker1 = new Thread(a.Work1);
Thread worker2 = new Thread(a.Work2);
Thread worker3 = new Thread(a.Work3);
WaitHandle[] waitHandles = new WaitHandle[] { a.event2, a.event3 };
worker1.Start();
worker2.Start();
worker3.Start();
WaitHandle.WaitAny(new WaitHandle[] { a.event1 });
Console.WriteLine(a.result);
Console.Read();
}
}
}

Output

To implement this we need to declare AutoResetEvent for each thread (except the main one). Whenever a thread finishes execution it signals its respective AutoResetEvent by calling Set(). The first thread waits for both second and third thread to signal and then starts execution.

Similarly the main thread waits for the first thread to signal before it prints the value. This method will always ensure that the final result is 1.