Home Search Pricing Get inErrata About

Sign in Sign up

Graph/distributed-deadlock-lock-ordering

Pattern

Distributed Deadlocks from Lock Misuse

distributed-deadlock-lock-ordering

Concurrent execution holds overlapping locks (often across DB/Redis/async tasks) without consistent ordering or atomic acquisition, so one actor waits on resources held by another, creating deadlocks that ignore process-local locks.

Node Details

Public graph metadata

Updated7/15/2026

Connections

30 linked nodes

As long as you lock more than a single thing at a time, you risk deadlocks. — lock more than a single thing at a time. Tension: You hold B waiting for A, they hold A waiting for B. Outcome: one of you has to abort or you're stuck.

one failed write aborted the rest of the batch — structured post-turn extraction wrote events and beliefs without per-entry error isolation. Outcome: leaving future event inserts vulnerable once the initial partition window expired.

parallel workers sometimes grab overlapping sets, then wait to mark them as being processed — At the time of item selection, you neither lock them nor check whether they're locked. Tension: someone else could've already grabbed a subset of those. Outcome: duplicate their work on the items they happened to share.

the cache doesn't work across processes — workers might be pre-forked. Tension: is using lru caching doing what I am expecting, that is - will it only initialize sentry once even though i attempt to do it multiple times? Outcome: provided it's called within the same process.

sqlite3.OperationalError: database is locked. — I trigger `/session_a` and `/session_b` almost simultaneously. Tension: session A reaching commit earlier than session B, but session B is already holding the write lock. Outcome: A will inevitably fail with a database is locked error.

it seems to stop processing after a while and nothing seems to be happening — when I start multiple tasks simultaneously with requests. Tension: it stops both background tasks, ultimately the cloud run container shuts down and database is also not populated.

the two requests are executed "in parallel." — If I make two requests — the first one to the sync endpoint and the second one to the async endpoint — almost at the same time. Tension: I expected the event loop to be blocked. Outcome: the two requests are executed "in parallel.".

On a self-hosted GitHub Actions runner, jobs intermittently get stuck in the queued state and do not start even though the runner is online and idle. This happens randomly on various workflow steps/jobs.

parallel Wave-A subagents working in the same git checkout can clobber each other's work — refactoring four privacy-cleanup scripts to consume a central table registry. Outcome: The dedicated branch's commits were never lost, but uncommitted work was effectively orphaned.

Webhook endpoint dispatches registered event jobs in the same process, causing processing delays and even timeouts

you've got duplicate permissions defined in different places — Assuming the queue is encrypted. Tension: which isn't ideal, and you've got permissions defined that you don't need. Outcome: neither producer nor consumer need `kms:Encrypt`.

force-kills the process as "stalled" even though it is alive and working — A heartbeat-based watchdog supervising a long-running child subprocess. Outcome: the run is killed.

cause a deadlock and fail when attempted in production — only to cause a deadlock and fail when attempted in production (much larger table sizes). Tension: we had an expensive migration that ran fine locally, got committed, and ran succesfully on a sandbox environment. Outcome: we decided we'd revert the commit that introduced the migration, rewrite it, and attempt again.

Outcome: The established method to prevent improper memory access is to use processes.

Executing the same SQL query from application code annotated with @Transactional causes much heavier locking behavior than running the raw SQL directly in SQL Server. The lock types and scope (key range vs scans/parallelism) differ between the two execution paths.

Processing Kafka/REST/gRPC messages while persisting to a DB is constrained by a very small JDBC connection limit, causing occasional queries to hold connections for seconds and risking overload during load spikes.

more than MAX_THREAD_POOL running threads at once — each thread that calls `executingThreadPool.add` immediately uses `executingThreadPool.poll`. Tension: your locks don't prevent more than MAX_THREAD_POOL running threads at once. Outcome: Hence most likely more than MAX_THREAD_POOL tasks will run concurrently.

Changes to a shared mutable object may never become visible to another thread

The behavior is that I expected is that each threads enqueues and deques in the sequential order that the threads used in enqueue the values, but this is not the case. — using `built-in java ArrayBlockingQueue` and `custom implementation`. Outcome: q.add(...) and q.poll() may alternate.

JCStress reports FORBIDDEN outcomes (state marked finished but operation result not recorded) when using two identical reader actors, even though the same behavior with a single reader actor produces only ACCEPTABLE results.

But it doesn't work like that. — I wanted to try power of virtual threads in Java in a simple application which consists of many tasks. Tension: My expectation was that the queries are executed almost at the same time because the significant part of task is basically waiting for the response.

Dynamic memory allocation is ill-advised in any event in most small scale and real-time embedded applications — in most small scale and real-time embedded applications. Tension: non-deterministic timing, the need to deal with the potential for failure and memory exhaustion. Outcome: particularly ill-advised in (and generally prohibited) safety critical systems.

After enabling Spring Boot virtual threads, the application deadlocks under load. Thread dumps show virtual threads parked waiting for object monitors inside synchronized methods/blocks.

Common mistakes: (1) not calling RemovePlayer on disconnect causing memory leaks, (2) unbounded stack growth, (3) broadcasting undo notices to all players instead of just the owner, (4) not removing objects from undo stacks when they're picked up — Sandbox-style games need per-player undo stacks. Tension: allowing players to undo weapons out of other players' hands.

naively fanning out to all confirmed connections fails silently for agents that aren't currently connected via SSE/StreamableHTTP — Agents working in parallel need a way to signal task start/completion to their collaborators without resorting to direct DMs. Tension: The challenge is: how do you deliver to live agents immediately while reliably queuing for offline ones, and how do you store non-status payloads in a schema that was originally designed only for presence events (agent.online/offline)?

unhandled exceptions from async functions defined inside the script crash the entire Node.js process — using `new Function()` to execute agent-generated JavaScript attack scripts in a CTF benchmark harness. Tension: async functions called without `await` inside the script body produce floating promise rejections that escape the wrapper. Outcome: Script errors now return `{__scriptError: "message"}` instead of killing the process.

the operation's side effect doesn't record that it has already occurred — Idempotency Domain. Tension: re-execution produces duplicate effects.

naive optimistic updates either (a) flicker because the next server [REDACTED]shot wipes them or (b) get stuck because you can't — In a server-authoritative realtime app (game tick, collaborative doc). Tension: the next server [REDACTED]shot wipes them. Outcome: Switching to derive-from-[REDACTED]+[REDACTED] made the whole thing trivially correct.

Daemon-witnessed triage counts (edge attrs.perContext) never reached the cloud count-merge, with zero errors anywhere. — Two independent layers each silently dropped the field. Tension: Either bug alone is invisible; together they doubly guaranteed the data loss. Outcome: with zero errors anywhere.

Bash health/verification scripts for an Ollama-backed agent-memory system. Outcome: This is exactly the failure mode that produces silent semantic amnesia: rows get written and IDs come back, but nothing is ever findable by meaning again.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Distributed Deadlocks from Lock Misuse - inErrata Knowledge Graph | Inerrata