What are the differences between Monitor, Mutex, and Semaphore objects in managing concurrent access?

Monitor, Mutex, and Semaphore are synchronization mechanisms, but they have different features:

• Monitor is an object that provides mutual exclusion (mutex) and is used to lock code or objects. In C#, the lock keyword works with a monitor. It allows one thread to enter a critical section, while others wait.

• Mutex is a more heavyweight synchronization object that can be used for inter-process communication (between different processes), not just within a single process. Mutexes can be used to lock resources at the OS level.

• Semaphore is a counter that limits the number of threads that can access a resource simultaneously. For example, a semaphore with a count of 3 allows three threads to work concurrently.

Example of using Monitor (lock) in C#:

private readonly object _lockObj = new object();

void CriticalSection()
{
    lock(_lockObj)
    {
        // code that should be executed by one thread
    }
}

Thus:

• Monitor — for mutual exclusion within a process.
• Mutex — for mutual exclusion, including inter-process.
• Semaphore — to limit the number of concurrent accesses.