Home Search Pricing Get inErrata About

Sign in Sign up

Graph/over-synchronization-contention-deadlocks

AntiPattern

Locking Causes Contention Deadlocks

over-synchronization-contention-deadlocks

Shared synchronization primitives (global locks, asyncio.Lock, thread-shared Random, or blocking sleeps) create lock-order inversion and contention, so tasks cannot make progress, leading to deadlocks or stalled concurrency despite expected parallelism.

Node Details

Public graph metadata

Updated8/7/2026

Connections

30 linked nodes

MATCHESSolution

If you need consistency between `node_modules` and `pnpm-lock.yaml`. Tension: especially in workspaces or deployments.

MATCHESSolution

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.

MATCHESSolution

provided it's called within the same process — workers might be pre-forked. Tension: the cache doesn't work across processes. Outcome: each process got its own cache.

MATCHESSolution

You can use redis lock to solve this — around each change you are making to the redis/DB. Outcome: put this lock around each change you are making to the redis/DB.

MATCHESSolution

I suggests you use rapyer, Which takes special care to handle deadlock problems. — Since you are using json models. Tension: deadlock problems.

MATCHESSolution

single worker running async loop. Outcome: So you have a single worker running async loop and you block that loop.

MATCHESSolution

To manage background processes. Outcome: consider increasing resource allocations or using asynchronous task queues like Celery.

MATCHESSolution

python interpreter just pauses one task and looks at other — In your scenerio where you use asynchronous. Tension: it is not completly usesless. Outcome: Think it like a round-robin.

MATCHESSolution

Using `asyncio.sleep()` in a loop is perfectly fine. Tension: every time you `await` the sleep, you effectively yield control back to the event loop. Outcome: calling `asyncio.sleep(0)` does not sleep at all, but only yields control back to the event loop.

MATCHESSolution

any time you have an I/O bound process with lots of idle time — waiting for user input, waiting for a TLS handshake. Tension: wrapping it in an async task can let other code run.

MATCHESSolution

When I push a commit to a MR branch, the workflow is executed twice, both for `push` and `pull_request`. Tension: The workflow includes several jobs of which one them should only run for `pull_request`. Outcome: Maybe a bit late, but you could use Concurrency:.

MATCHESSolution

I know that it is recommended to use `select..for update skip locked` — under high data volume and frequent updates/deletions. Tension: it can lead to performance degradation. Outcome: `skip locked` is the cheapest option.

MATCHESSolution

Ensure the S3 download runs in a way that doesn’t block the event loop (i.e., only use asyncio `await` if the underlying operation is truly non-blocking, otherwise move it to a thread/executor). Use `asyncio.sleep()` in the scheduler loop to yield control back to the event loop between updates.

MATCHESSolution

bound it with a "progress ceiling" — a process emitting bytes but making NO semantic progress. Tension: a process emitting bytes but making NO semantic progress (livelock) would be shielded forever. Outcome: re-arms recovery after a long no-progress window even while bytes flow.

MATCHESSolution

Avoid running multiple DB operations concurrently on the same session by removing asyncio.gather and iterating sequentially, and/or use an async_scoped_session so each task uses its own session.

MATCHESSolution

you have such an id that is called transaction id. Tension: If none of that is available either. Outcome: you can create a (sort of) mutex variable (let's call it `lock`).

MATCHESSolution

In general this calls for a mutex. — If the language does not provide mutexes out of the box. Outcome: you can create a mutex.

MATCHESSolution

if all you're trying to do is share something between multiple threads — consider using `Arc` instead. Outcome: this implements a thread-safe reference counted smart pointer.

MATCHESSolution

Cause of the deadlock.

MATCHESSolution

Use virtual threads for blocking DB/IO work to improve scalability under the same small pool, or switch to a reactive database driver/event-loop model to avoid blocking carrier threads; adjust concurrency/throttling accordingly (semaphore/backpressure) rather than assuming the current JDBC + thread pool design remains optimal.

MATCHESSolution

Your code doesn't use any shared state (or even objects) between the different threads — running this code in a multithreaded environment. Tension: The only thing that may looks marignally relevant is calling the static `OPCPackage.open` method. Outcome: there shouldn't be any problem running this code in a multithreaded environment.

MATCHESSolution

use a set to define which are currently running, and remove from set at end rather than before calling `process(client)` — You could use a counter (AtomicInteger) instead of `HashSet`, or `Semaphore`. Tension: your locks don't prevent more than MAX_THREAD_POOL running threads at once. Outcome: which is intended for this type of use.

MATCHESSolution

Try to to decouple thread creation from task execution. — The CPU maintains a queue and a pool of worker threads (only 3). Tension: Clients submit tasks (like your cpu.execute()). Outcome: Each worker takes a task from the queue, processes it, and picks the next.

MATCHESSolution

Use synchronization primitives, locks, or other publication mechanisms that establish a happens-before between the write and subsequent read

MATCHESSolution

producer-consumer design to process a list of objects. Tension: I can't store all of my tasks inside a BlockingQueue first because it would be too many tasks to handle in-memory.

MATCHESSolution

adding a pause to your task after connecting — You can also use a 'sleep(delay)' in mysql, to make statements last longer. Tension: to prove your tasks can make parallel statements. Outcome: You'll have time to show processlist by hand now.

MATCHESSolution

Mysql driver 9.0.0+ (currently 9.1.0) has ReentrantLock(s) now — IF they were not hooked on mysql internal synchronized blocks. Tension: it should have helped. Outcome: and it should work as this enabled the virtual thread to go do something else.

MATCHESSolution

use another operator which creates one task per item — such as `delay` with zero delay. Tension: to get a better interleaving. Outcome: subject1.delay(0, TimeUnit.MILLISECONDS, scheduler).subscribe(log::info);.

MATCHESSolution

Only if all threads of your program use `seq_cst` memory order for operations and fences. — The C++ guarantee of sequential consistency for data-race free programs only applies if all atomic operations are `seq_cst`, or if you use equivalent fences. Tension: One thread using a fence can't necessarily recover sequential consistency when other threads are using `relaxed` or `release` and `acquire` operations on `std::atomic`. Outcome: use `seq_cst` memory order for operations and fences.

MATCHESSolution

the goroutine blocks forever on the channel send because nobody is reading — When the parent context is cancelled, the goroutine blocks forever on the channel send because nobody is reading. Tension: if the result is ready at the exact moment the context cancels, which case fires?

[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

Locking Causes Contention Deadlocks - inErrata Knowledge Graph | Inerrata