Question

Under what circumstances should each of the following synchronization objects be used?

1. ReaderWriter lock
2. Semaphore
3. Mutex

Answer 1

• Since wait() will return once for each time post() is called, semaphores are a basic producer-consumer model – the simplest form of inter-thread message except maybe signals. They are used so one thread can tell another thread that something has happened that it’s interested in (and how many times), and for managing access to resources which can have at most a fixed finite number of users. They offer ordering guarantees needed for multi-threaded code.

• Mutexes do what they say on the tin – ‘mutual exclusion’. They ensure that the right to access some resource is ‘held’ by only on thread at a time. This gives guarantees of atomicity and ordering needed for multi-threaded code. On most OSes, they also offer reasonably sophisticated waiter behaviour, in particular to avoid priority inversion.

Note that a semaphore can easily be used to implement mutual exclusion, but that because a semaphore does not have an ‘owner thread’, you don’t get priority inversion avoidance with semaphores. So they are not suitable for all uses which require a ‘lock’.

• ReaderWriter locks are an optimisation over mutexes, in cases where you will have a lot of contention, most accesses are read-only, and simultaneous reads are permissible for the data structure being protected. In such cases, exclusion is required only when a writer is involved – readers don’t need to be excluded from each other. To promote a reader to writer all other readers must finish (or abort and start waiting to retry if they also wish to become writers) before the writer lock is acquired. ReaderWriter locks are likely to be slower in cases where they aren’t faster, due to the additional book-keeping they do over mutexes.

• Condition variables are for allowing threads to wait on certain facts or combinations of facts being true, where the condition in question is more complex than just ‘it has been poked’ as for semaphores, or ‘nobody else is using it’ for mutexes and the writer part of reader-writer locks, or ‘no writers are using it’ for the reader part of reader-writer locks. They are also used where the triggering condition is different for different waiting threads, but depends on some or all of the same state (memory locations or whatever).

• Spin locks are for when you will be waiting a very short period of time (like a few cycles) on one processor or core, while another core (or piece of hardware such as an I/O bus) simultaneously does some work that you care about. In some cases they give a performance enhancement over other primitives such as semaphores or interrupts, but must be used with extreme care (since lock-free algorithms are difficult in modern memory models) and only when proven necessary (since bright ideas to avoid system primitives are often premature optimisation).

Btw, these answers aren’t C# specific (hence for example the comment about ‘most OSes’). Richard makes the excellent point that in C# you should be using plain old locks where appropriate. I believe Monitors are a mutex/condition variable pair rolled into one object.