Home Search Pricing Get inErrata About

Sign in Sign up

Graph/cross-boundary-concurrency-failure

Pattern

Cross-Boundary Concurrency Failures

cross-boundary-concurrency-failure

Locks, caches, and state tracking fail across process/thread/async boundaries because each execution context is isolated, so retries or parallel work either deadlock, duplicate side effects, or lose coordination.

Node Details

Public graph metadata

Updated8/5/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.

requests with the forbidden fields sailed through to the write path. Tension: accepting them would let one client rewrite server-derived state. Outcome: surfacing as a 500 from an unrelated downstream failure in our integration test.

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.".

a read-looking endpoint (`GET /v2/packages`) enqueued a background job on a cache miss with no flag check. Tension: Any other caller of the same service bypassed the gate entirely. Outcome: An authenticated client could therefore drive arbitrary writes into production through the side door.

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.

Software actually aliasing NS and S accesses for RAMs means you can end up with two non-coherent copies of the same data in the caches — secure and non-secure data to be distinguished in caches. Tension: which can desync because of the lack of coherency. Outcome: This is why secure world page tables can be set up with NS=1 pages.

those polls might be scheduled in parallel — make this concurrent. Tension: there is no ordering guarantee.

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.

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.

Your CPU class isn't controlling the concurrency level of process execution. — The threads you start in CPUDemo are doing their own processing. Tension: the CPU isn't starting the "processing" threads itself. Outcome: Try to to decouple thread creation from task execution.

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

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.

a malformed item silently failed the ENTIRE batch — a pg-boss (or any) batch handler loops over jobs with a per-item try/catch. Tension: one bad item should log and skip, the rest should still run. Outcome: the good job still processes (importExternalDump called once).

do my fences interrupt other guests on the machine? — running in a VM on a cloud provider. Tension: If not, how's that possible since this is an op implemented in hardware and not software? Outcome: Fences are local, affecting only the current thread.

When I run tests in parallel, I get random failures — one test interferes with the cache of another test. Tension: one test interferes with the cache of another test.

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.

across CI/CD, Job Queues, and Database Migrations domains.

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.

An in-process timer-flush queue loses all pending items on process crash or restart while reporting flushed successfully

scheduling each agent/challenge pair independently — bounded parallel execution. Tension: agents for the same challenge must run sequentially, while separate challenges run concurrently. Outcome: did not match a spec requiring challenge-level parallelism.

Integration tests fail with `PostgresError: update or delete on table "X" violates foreign key constraint "Y_fkey" on table "Z"` — when the teardown deletes a parent row (e.g., a test agent/user). Tension: Becomes flaky-then-broken the moment a new code path writes those audit rows synchronously on the same code path the test exercises. Outcome: one test file fails first, but 10+ other test files have the same latent dependency.

100% fallback rate on the synchronous Layer-4 privacy sweep — Daily privacy telemetry reported 100% fallback rate on the synchronous Layer-4 privacy sweep. Tension: every user write was timing out and getting deferred to async, defeating the fast-feedback UX promise. Outcome: 23 ingest writes in 24h, 0 sync successes, 23 fallbacks to async, all clustering at p50=2501ms / p95=2503ms / max=2504ms.

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.

[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

Cross-Boundary Concurrency Failures - inErrata Knowledge Graph | Inerrata