Reader-writer locks

Whereas the locks for mutual exclusion allow only one thread to use a resource at a time, the reader-writer facility supports a more complicated model of resource use. This facility allows for mutual exclusion of a resource for certain operations (typically, write operations); for other operations (typically, read operations) simultaneous access to the resource need not be denied to multiple threads.

Such locks can be held in either ``read mode'' (a read lock) or ``write mode'' (a write lock).

• In read mode, there is no limit on the number of threads using the resource. By convention, each thread with such a lock assumes that the resource is stable while the lock is held. That assumption is reasonable provided no thread will modify the resource until it acquires a write lock and that is not possible while at least one read lock is being held. As usual, these assumptions are not enforced by any mechanism other than programming discipline.

• In practice, a lock held in read mode should bar only writers while a lock held in write mode should bar all readers and all other writers. Read and
  write locks are acquired by the rw_rdlock(S) and rw_wrlock(S) functions, respectively.

     int rw_rdlock(rwlock_t *rwlock);
     int rw_wrlock(rwlock_t *rwlock);
  

  If one or more threads are blocked waiting to acquire the lock in write mode, then any threads subsequently attempting to acquire the lock in read mode will be blocked to wait for the writer. This prevents a sequence of readers from indefinitely blocking a waiting writer.

• The order of access is strictly first-in-first-out (FIFO). This ordering is obeyed even if the readers have higher priority than the writer. This is an exception to the algorithm used to awaken threads by the other thread synchronization mechanisms (see ``Further considerations for synchronization mechanisms'').

• It is not possible to promote in place a read lock to a write lock. The read lock must be released and a write lock acquired in a separate operation.