Home Search Pricing Get inErrata About

Sign in Sign up

Graph/thread-blocking-deadlock

Pattern

Thread Blocking Causes Deadlock

thread-blocking-deadlock

Lock contention and blocking calls make threads wait on each other, so retries, sleep, or shared driver locks stop progress and can look like hangs; deadlocks arise when multiple locks are held simultaneously.

Node Details

Public graph metadata

Updated7/23/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.

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.

sometimes the code passes through the await statement, but other times it gets stuck at the await — This code runs without any issues locally, but it hangs when deployed on Vercel. Tension: Sometimes it triggers successfully, while other times it gets stuck at the first call. Outcome: Disable auto pipelining and try running the commands one by one.

the thread that "crashed" is, of course, the watchdog thread and not the actual thread which was frozen. Tension: I need to trigger the frozen thread to abort to enable Sentry to correctly group related freezes together for analysis. Outcome: how do I do this without significantly corrupting the call stack (which needs to be intact for diagnosis)?

background task blocks eventloop — reload = True or workers > 1. Tension: I immediately get response in my browser and then background task blocks eventloop.

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.

Waiting for background tasks to complete. — Whenever I gracefully shut down my FastAPI app by saving a file (with the `--reload` option). Tension: "Shutting down sessions" is never logged because it is waiting for all background tasks to be completed, which will never happen. Outcome: How am I supposed to close my sessions so that FastAPI can properly shut down?

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.

Timeout waiting for connection from pool. Tension: Task 4217 in stage 4.0 failed 4 times. Outcome: Job aborted due to stage failure.

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.

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

I'm getting a TimeoutException on this line: — List handles = new ArrayList(driver.getWindowHandles());. Outcome: I was able to make the test pass with this code.

I can't store all of my tasks inside a BlockingQueue first because it would be too many tasks to handle in-memory

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.

Multiple threads are writing in the file concurrently. — I need to persist this counter because if process get restarted then it counter should start from last count. Tension: I hope there wont be a case when any number shall be skipped or give duplicate value to thread. Outcome: how to reset this key when value reaches to 25k in a thread safe way.

the Main thread was blocked till the subscribe method completion — Mono.just(getValue()).subscribe(value -> System.out.println(value));. Outcome: Can someone make this program asynchronous?

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.

the multithreaded version runs as long as the single threaded one — While writing a multithreaded application. Tension: I encountered a problem that the multithreaded version runs as long as the single threaded one.

what are the correct values of three highlighted parameters? — when it comes to intrusive lockless stacks (single-linked lists). Tension: I've seen various permutations of highlighted parameters. Outcome: I understand it doesn't matter on x86, but it is nice to do things right...

this does not happen — whenever the tracee creates a new thread. Tension: I must also follow all threads created by the traced program.

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.

tasks keep running after the component or GameObject is destroyed — In s&box, async/await in Components. Tension: Using raw Task.Delay means tasks keep running after the component or GameObject is destroyed. Outcome: causing null reference exceptions and ghost behavior.

Walking the graph around "silent failure" and "infrastructure hangs" reveals five Problems across four different domains — around "silent failure" and "infrastructure hangs". Tension: that share the same unextr.

Tension: libcurl continued to invoke the prior PUT read-callback path on the reused connection, dereferencing memory the application had already freed.

[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