Read-Write Locks

Learning Objectives

• Understand read-write locks.
• Learn the difference between readers and writers.
• Understand shared and exclusive locking.
• Learn when read-write locks are preferred over mutexes.
• Prepare for POSIX read-write lock APIs.

1. What is a Read-Write Lock?

A read-write lock is a synchronization object that permits multiple threads to hold the lock simultaneously for reading, provided no thread holds it for writing. When a thread acquires the lock for writing, exclusive access is granted and all other readers and writers must wait.

2. Why Read-Write Locks are Needed

3. Readers vs Writers

4. Shared vs Exclusive Access

5. Read-Write Lock vs Mutex

6. pthread_rwlock_t

POSIX represents a read-write lock using the pthread_rwlock_t data type. Applications declare one read-write lock for each shared resource requiring coordinated read and write access.

7. Read-Write Lock Lifecycle

8. When to Use Read-Write Locks

9. Example Scenario

10. Interview Questions

1. What is a read-write lock?
2. How does it differ from a mutex?
3. When should a read-write lock be used?
4. What is shared access?
5. What is exclusive access?
6. Can multiple readers hold the lock simultaneously?
7. Why must writers obtain exclusive access?
8. What is pthread_rwlock_t?
9. What types of applications benefit from read-write locks?
10. Describe the lifecycle of a read-write lock.

11. Static Read-Write Lock Initialization

POSIX provides the PTHREAD_RWLOCK_INITIALIZER macro for statically initializing a read-write lock with default attributes.

12. pthread_rwlock_init()

The pthread_rwlock_init() function initializes a read-write lock before it is used. Passing NULL for the attribute parameter selects the default attributes.

13. pthread_rwlock_destroy()

The pthread_rwlock_destroy() function releases the resources associated with a read-write lock. The lock must not be held by any thread when it is destroyed.

14. pthread_rwlock_rdlock()

The pthread_rwlock_rdlock() function acquires the read lock. Multiple threads may successfully acquire the read lock at the same time, provided that no thread currently holds the write lock.

15. Read Lock Workflow

16. pthread_rwlock_wrlock()

The pthread_rwlock_wrlock() function acquires the write lock. The calling thread blocks until no thread holds either a read lock or a write lock.

17. Write Lock Workflow

18. pthread_rwlock_unlock()

The pthread_rwlock_unlock() function releases either a read lock or a write lock held by the calling thread. After unlocking, waiting reader or writer threads may acquire the lock according to the implementation's scheduling policy.

19. Complete Initialization Example

20. Linux Commands

21. Interview Questions

1. What is PTHREAD_RWLOCK_INITIALIZER?
2. Why must a read-write lock be initialized?
3. What is the difference between pthread_rwlock_rdlock() and pthread_rwlock_wrlock()?
4. Can multiple readers hold the read lock simultaneously?
5. Why must writers wait for readers to finish?
6. When does pthread_rwlock_wrlock() block?
7. Can pthread_rwlock_unlock() release both read and write locks?
8. When should a read-write lock be destroyed?
9. Why are default attributes selected by passing NULL?
10. Describe the complete lifecycle of a read-write lock.

22. pthread_rwlock_tryrdlock()

The pthread_rwlock_tryrdlock() function attempts to acquire a read lock without blocking. If the lock cannot be acquired immediately, the function returns an error instead of waiting.

23. pthread_rwlock_trywrlock()

The pthread_rwlock_trywrlock() function attempts to acquire a write lock without blocking. If another reader or writer currently holds the lock, the function immediately returns an error.

24. Reader–Writer Example

25. Reader Workflow

26. Writer Workflow

27. pthread_rwlockattr_t

The pthread_rwlockattr_t data type stores attributes used during read-write lock initialization. Applications may configure the attribute object before calling pthread_rwlock_init().

28. Reader and Writer Starvation

POSIX does not define a mandatory scheduling policy for read-write locks. Fairness between readers and writers is implementation-defined.

29. Linux Commands

30. Advanced Interview Questions

1. What is the difference between pthread_rwlock_rdlock() and pthread_rwlock_tryrdlock()?
2. When should pthread_rwlock_trywrlock() be preferred?
3. What happens if a non-blocking lock request fails?
4. What is pthread_rwlockattr_t?
5. What is reader starvation?
6. What is writer starvation?
7. Does POSIX define a mandatory fairness policy for read-write locks?
8. When are read-write locks more efficient than mutexes?
9. Describe the complete reader workflow.
10. Describe the complete writer workflow.

31. pthread_rwlockattr_init()

The pthread_rwlockattr_init() function initializes a read-write lock attribute object with default values. The initialized attribute object may be modified before creating a read-write lock.

32. pthread_rwlockattr_destroy()

The pthread_rwlockattr_destroy() function releases resources associated with a read-write lock attribute object. After destruction, the attribute object should not be reused unless it is initialized again.

33. Read-Write Lock Attribute Lifecycle

34. Complete Attribute Example

35. Best Practices

• Use read-write locks only when read operations greatly outnumber write operations.
• Keep both read and write critical sections as short as possible.
• Always release the lock after completing the protected operation.
• Initialize and destroy read-write locks correctly.
• Avoid performing lengthy computations while holding a write lock.
• Check the return value of every POSIX thread function.
• Measure application performance before replacing mutexes with read-write locks.

36. Common Programming Mistakes

• Using a read-write lock for write-intensive workloads.
• Holding the write lock longer than necessary.
• Forgetting to unlock after reading or writing.
• Destroying a lock that is still in use.
• Ignoring errors returned by lock functions.
• Assuming all implementations provide identical fairness policies.
• Replacing every mutex with a read-write lock without evaluating performance.

37. Advanced Interview Questions

1. What is the purpose of pthread_rwlockattr_t?
2. Why must read-write lock attributes be initialized?
3. When should pthread_rwlockattr_destroy() be called?
4. Why are read-write locks recommended only for read-heavy workloads?
5. What causes reader starvation?
6. What causes writer starvation?
7. Can read-write locks always outperform mutexes?
8. Why should write critical sections remain short?
9. Describe the complete lifecycle of a read-write lock.
10. When should a mutex be preferred over a read-write lock?

38. Module Summary

In this module, we studied POSIX read-write locks and their use in synchronizing shared resources. We covered shared and exclusive locking, reader and writer operations, initialization, destruction, non-blocking lock operations, attribute objects, starvation, best practices, and common programming mistakes. Read-write locks improve concurrency by allowing multiple readers to access shared data simultaneously while ensuring exclusive access for writers.