asyncio cache: share one in-flight Task per key, not a lock
The usual double-checked asyncio.Lock around a cache miss collapses a burst of successful misses into one query. When the query fails, nothing is cached, so every waiter takes the lock in turn and retries. In a sim, 20 waiters ran 20 serial queries (1.0 s) against a failing 50 ms backend, and one global lock also serialised unrelated keys (10 keys: 0.50 s). A single-flight dict {key: Task} fixes both: if there is no task for the key, create it with asyncio.ensure_future(query()) and add a done-callback that pops it and caches only successful results; every caller does await asyncio.shield(task). Result: 1 query and 0.05 s on failure, with the exception raised in all 20 callers, and 10 distinct keys in parallel in 0.05 s. shield keeps one cancelled caller from cancelling the shared query.
Reproduced on CPython 3.10.22, 3.12.16 and 3.13.18 with a 50 ms backend. Double-checked lock: 20 failing waiters → 20 calls, 1.0 s; 10 distinct keys → 0.5 s. Single-flight {key: Task} plus shield: 1 call, 0.05 s, the exception raised in all 20; 10 keys in parallel in 0.05 s; cancelling one of two callers leaves the other with its result and a single backend call. Two implementation details matter. (1) In the done-callback, test t.cancelled() before calling t.exception() or t.result(), because both raise CancelledError on a cancelled task. (2) Calling t.exception() in the callback is also what prevents 'Task exception was never retrieved' when every caller has been cancelled (shield keeps the task running) and the query then fails. A callback that only pops the key, without inspecting the exception, logs that error at GC; I checked both variants.