Reader-Writer Lock

1.0.9 · active · verified Fri Apr 10

The `readerwriterlock` library provides a Python 3 implementation of the three classic Reader-Writer problems. It offers different lock types (Reader priority, Writer priority, Fair priority) and is compliant with the standard Python lock interface, including support for timeouts. The current version is 1.0.9, and releases are infrequent, indicating a stable and mature library.

Warnings

gotcha Versions prior to 1.0.9, when used with Python 3.9.7, could encounter a `TypeError: Protocols cannot be instantiated` due to an incompatibility with `typing.Protocol`.
Fix: Upgrade `readerwriterlock` to version 1.0.9 or newer. Alternatively, upgrade Python to a version beyond 3.9.7 (e.g., 3.9.8+ or 3.10+).
gotcha The downgradable lock classes (`RWLockReadD`, `RWLockWriteD`, `RWLockFairD`) introduce a theoretical ~20% performance overhead for acquiring and releasing locks compared to their non-downgradable counterparts.
Fix: For performance-critical sections where atomic downgrade from write-lock to read-lock is not required, use the non-downgradable lock classes (`RWLockRead`, `RWLockWrite`, `RWLockFair`).
gotcha This library implements reader-writer locks for *threads* within a single process. It does not support inter-process communication or distributed locking.
Fix: For inter-process or distributed reader-writer locks, consider alternative libraries like `fasteners.InterProcessReaderWriterLock` or `redisrwlock`, or implement custom solutions using `multiprocessing.Lock` or `ctypes` and `mmap` for POSIX shared memory locks.
gotcha Python 3.13+ is planned to include a built-in `threading.RWLock`. Users on newer Python versions may consider using the standard library implementation over this third-party library.
Fix: Review the Python standard library documentation for `threading.RWLock` (when available in Python 3.13+) to evaluate if it meets your needs.

Install

pip install readerwriterlock Install stable version

Imports

RWLockRead, RWLockWrite, RWLockFair
```
from readerwriterlock import rwlock
lock = rwlock.RWLockFair()
```
The lock classes are nested within the 'rwlock' submodule, not directly under 'readerwriterlock'.
RWLockReadD, RWLockWriteD, RWLockFairD
```
from readerwriterlock import rwlock
lock = rwlock.RWLockFairD()
```
These are the downgradable versions of the locks.

Quickstart

This example demonstrates how to use `RWLockFairD` to protect a shared resource. Multiple reader threads can access the resource concurrently, while writer threads gain exclusive access. The `gen_rlock()` and `gen_wlock()` methods create context managers for acquiring and releasing read and write locks, respectively.

from readerwriterlock import rwlock
import threading
import time

# Choose a fair, downgradable lock for a balanced approach
lock = rwlock.RWLockFairD()

shared_resource = []

def reader(reader_id):
    with lock.gen_rlock():
        # Multiple readers can enter this block concurrently
        print(f"Reader {reader_id}: Reading {shared_resource}")
        time.sleep(0.1) # Simulate read operation

def writer(writer_id):
    with lock.gen_wlock():
        # Only one writer can enter this block
        old_val = list(shared_resource)
        shared_resource.append(writer_id)
        print(f"Writer {writer_id}: Wrote {writer_id}, was {old_val}, now {shared_resource}")
        time.sleep(0.2) # Simulate write operation


threads = []
for i in range(3):
    threads.append(threading.Thread(target=reader, args=(f'R{i}',)))
    threads.append(threading.Thread(target=writer, args=(f'W{i}',)))

for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"Final resource state: {shared_resource}")

view raw JSON →