aiorwlock: Read Write Lock for Asyncio

1.5.1 · active · verified Fri Apr 10

aiorwlock provides a read-write lock, a synchronization primitive for `asyncio` applications. It allows multiple reader tasks to hold a lock concurrently, while a writer task obtains an exclusive lock, blocking all readers and other writers. This pattern is ideal for resources that are frequently read but infrequently written. The library is currently at version 1.5.1 and maintains an active release cadence with several minor and patch updates per year.

Warnings

breaking Python 3.7 support was dropped in v1.4.0. Users on Python 3.7 or older must upgrade their Python version to use `aiorwlock` v1.4.0 or newer.
Fix: Upgrade Python to 3.8 or newer. The current minimum supported version is Python 3.9.
breaking The explicit `loop` parameter for the `RWLock` constructor was deprecated in v1.0.0 and removed in v1.3.0. Passing a `loop` argument will now raise an error.
Fix: Remove the `loop` argument from `RWLock()` constructor calls. `aiorwlock` now lazily evaluates the current event loop.
deprecated Creation of `RWLock` instances outside of an `async` function context was deprecated in v1.0.0. While it might still work in some setups due to lazy loop evaluation, it's considered bad practice.
Fix: Ensure `RWLock()` instances are created within an `async` function or a context where `asyncio.get_running_loop()` can correctly resolve the event loop.
gotcha Fixed a cross-event-loop race condition in lock acquisition and a deadlock that could occur when tasks are cancelled.
Fix: Upgrade to `aiorwlock` v1.5.1 or newer to benefit from critical stability fixes.
gotcha Fixed a bug that allowed concurrent writes under rare conditions.
Fix: Upgrade to `aiorwlock` v1.2.0 or newer to ensure correct exclusive write lock behavior.
gotcha A `RuntimeError` will be raised if a lock is acquired by one task but released by another. Synchronization primitives in `asyncio` are typically task-bound.
Fix: Always ensure that the same `async` task (coroutine) that acquires a `reader_lock` or `writer_lock` is also responsible for releasing it (e.g., by using `async with`).

Install

pip install aiorwlock Install latest version

Imports

RWLock
```
from aiorwlock import RWLock
```

Quickstart

This example demonstrates basic usage of `RWLock` with multiple concurrent readers and a single writer. Readers can acquire the `reader_lock` simultaneously, but a writer acquiring the `writer_lock` will block all other readers and writers.

import asyncio
from aiorwlock import RWLock

async def reader_task(rwlock: RWLock, reader_id: int):
    print(f"Reader {reader_id}: Attempting to acquire read lock")
    async with rwlock.reader_lock:
        print(f"Reader {reader_id}: Acquired read lock")
        await asyncio.sleep(0.05) # Simulate reading
        print(f"Reader {reader_id}: Released read lock")

async def writer_task(rwlock: RWLock, writer_id: int):
    print(f"Writer {writer_id}: Attempting to acquire write lock")
    async with rwlock.writer_lock:
        print(f"Writer {writer_id}: Acquired write lock")
        await asyncio.sleep(0.1) # Simulate writing
        print(f"Writer {writer_id}: Released write lock")

async def main():
    rwlock = RWLock()
    tasks = []
    # Start some readers
    for i in range(3):
        tasks.append(asyncio.create_task(reader_task(rwlock, i)))
    # Start a writer in between
    tasks.append(asyncio.create_task(writer_task(rwlock, 100)))
    # Start more readers
    for i in range(3, 6):
        tasks.append(asyncio.create_task(reader_task(rwlock, i)))

    await asyncio.gather(*tasks)

if __name__ == "__main__":
    asyncio.run(main())

view raw JSON →