Repair Thread Pool Starvation

The problem

Thread pool starvation occurs when tasks occupy every worker while synchronously waiting for child tasks queued to that same exhausted pool. This creates a capacity dependency cycle where the CPU sits idle while the application freezes under load.

What it does

• Identifies blocking and completion edges across request, child, and shutdown task paths.
• Reconstructs the smallest saturation state to isolate capacity dependency cycles.
• Removes same-pool blocking by implementing nonblocking composition or executor separation.
• Preserves existing backpressure, rejection, and timeout semantics without increasing worker counts.
• Builds deterministic saturation tests using exact-capacity barriers instead of sleeps.

Frameworks & tools

Works with Java/JVM (java.util.concurrent), C# (.NET Task Parallel Library), Python (concurrent.futures), and Go. Compatible with any environment using fixed or bounded executors.

Why this beats prompting it yourself

Most LLMs suggest increasing thread counts or timeouts, which only delays the crash. This skill enforces an acyclic task-capacity contract, identifying the structural dependency flaw that causes the freeze rather than just treating the symptoms.

Use cases

• Fixing deadlocks where parent tasks wait for child tasks in the same saturated pool.
• Resolving shutdown sequences that hang behind tasks they are trying to drain.
• Remediating throughput collapse in systems using nested submissions.
• Verifying concurrency fixes with high-fidelity saturation tests.

Known limitations

Cannot move blocking work onto event loops or modify production worker counts. Requires repository access to inspect executor configurations and task submission paths.