Spawning off multiple thread using for loop in C#

Question

I am spawning 10 threads using a for loop in C# as shown below

internal class Program
{
    static Mutex mutex = new Mutex();
    static void Main(string[] args)
    {
        for (int i = 0; i < 10; i++)
        {
            Thread t1 = new Thread(AcquireMutex);
            t1.Name = string.Format("Thread{0}", i + 1);
            t1.Start();
        }
        
    }

    private static void AcquireMutex(object? obj)
    {
        mutex.WaitOne();
        DoSomething();
        mutex.ReleaseMutex();
        Console.WriteLine("Mutex released by {0}", Thread.CurrentThread.Name);
    }

    private static void DoSomething()
    {
        Thread.Sleep(1000);
        Console.WriteLine("Mutex acquired by {0}", Thread.CurrentThread.Name);
    }
}

As per my understanding, in the first iteration of the for loop Thread 1 starts and so on. But while running the above code,I came to see that Thread 10 acquires the mutex lock before Thread 1 in some cases.

So my query is , if the for loop spawns Thread 1 first ,then Thread 10, why does Thread 10 acquires the lock first in some cases?

Answer 1

So my query is, if the for loop spawns Thread 1 first, then Thread 10, why does Thread 10 acquires the lock first in some cases?

Welcome to the world of multithreading. The reason we start multiple threads is because we want things to run in parallel, and in parallelism the concept of order does not apply. Things are running concurrently, not the one after the other. The work is delegated to the operating system, that assigns physical CPU cores to software threads according to its own heuristics, without much consideration about what these threads are actually doing. The cores are assigned to threads in time-slices, so that the number of threads that can make progress concurrently is much larger than the number of physical CPU cores. A time-slice might end at any arbitrary point. For example a thread can be suspended by the OS in the middle of a x = x + 1 operation (which is translated to multiple CPU instructions), and resumed 50 milliseconds later overwriting any modifications on x that other threads might have done in the meantime.

If you need to restore the order in the chaos, and run specific parts of your multithreaded code not only sequentially (not concurrently) but also in a predefined order, there is no built-in synchronization primitive that can help you achieve this goal. There are two relevant primitives, the CountdownEvent and the Barrier, but they are not doing exactly what you want. You might find a solution in this question: Is there a synchronization class that guarantee FIFO order in C#?