If a thread is the owner of one or more exclusive write locks acquired by pthread_rwlock_wrlock(), pthread_rwlock_trywrlock() or pthread_rwlock_timedwrlock_np(), when that thread terminates, the exclusive write locks will NOT be automatically released by the system. This is an error in the application, and indicates that the data associated with the lock is in an inconsistent state. If another thread attempts to get a shared read or exclusive write lock on the lock, that thread will block forever.

Read/write locks can be upgraded / downgraded

• If a thread currently holds a shared read lock, an attempt by the same thread to acquire an exclusive write lock will succeed if no other threads hold a shared read lock. The thread then holds both an exclusive write lock and a shared read lock.
• If a thread currently holds an exclusive write lock, an attempt by the thread to acquire a shared read lock will succeed. The thread then holds both an exclusive write lock and a shared read lock.
• In the case that a thread holds one or more shared read locks and one or more exclusive write locks on the same read/write lock object at the same time. A call to pthread_rwlock_unlock(), will always unlock the exclusive write lock FIRST.
• When multiple exclusive write locks and multiple exclusive read locks are held by the same thread on the same read/write lock object, the behavior of pthread_rwlock_unlock() is as follows:
  • A call to the pthread_rwlock_unlock() function will always unlock the most recent exclusive write lock first.
  • Subsequent calls to pthread_rwlock_unlock() will first reduce the count of any outstanding exclusive write locks held by the thread until all exclusive write locks are unlocked.
  • After all outstanding exclusive write locks are unlocked, and the thread holds only shared read locks on the read/write lock object, a call to pthread_rwlock_unlock() function will then unlock the most recent shared read lock.
  • Subsequent calls to pthread_rwlock_unlock() will reduce the count of any outstanding shared read locks held by the thread until all shared read locks are unlocked.

{
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
pthread_rwlock_rdlock(&rwlock);
...
/* Thread holding a read lock decides it needs to upgrade to a write lock */
/* Now Upgrade to write lock */
pthread_rwlock_wrlock(&rwlock);
...
/* write lock (and read lock) are held here.*/
/* We've effectively upgraded to a write lock */
...
/* `Downgrade' back to a only the read lock */
pthread_rwlock_unlock(&rwlock);
...
/* unlock the read lock */
pthread_rwlock_unlock(&rwlock);
}

{
pthread_rwlock_t rwlock = PTHREAD_RWLOCK_INITIALIZER;
pthread_rwlock_wrlock(&rwlock);
..
/* Thread holding the write lock decides it needs to downgrade to a read lock */
/* Get the read lock, so we're holding BOTH read and write locks */
pthread_rwlock_rdlock(&rwlock);
...
/* An unlock always unlocks the write lock first */
pthread_wrlock_unlock(&rwlock);
...
/* At this point, we're only holding the read lock. */
/* We've effectively downgraded the write lock to a read lock */
...
/* Use unlock to unlock the last read lock. */
pthread_wrlock_unlock(&rwlock);
}