Consider the classic readers$-$writers synchronization problem described below. Several

threads wish to read and write data shared between them. Some threads only want to

read the shared data $($readers$),$ while others want to update the shared data as well

$($writers$).$ Multiple readers may concurrently access the data safely, without any

correctness issues. However, a writer must not access the data concurrently with anyone

else, either a reader or a writer. While it is possible for each reader and writer to acquire

a regular mutex and operate in perfect mutual exclusion, such a solution will be missing

out on the benefits of allowing multiple readers to read at the same time without

waiting for other readers to finish. Therefore, we wish to have special kinds of locks

called reader$-$writer locks that can be acquired by processes$/$threads in such situations.

These locks have separate lock$/$unlock functions, depending on whether the thread

asking for a lock is a reader or writer. If one reader asks for a lock while another reader

already has it$,$ the second reader will also be granted a read lock $($unlike in the case of a

regular mutex$),$ thus encouraging more concurrency in the application