Calculate optimal thread count for a workload based on core count and I/O wait ratio.
Every thread on Linux is represented internally as a task_struct, the same structure used for whole processes, and the kernel caps the total system-wide count via kernel.threads-max (auto-tuned at boot based on RAM, but overridable via sysctl). Summing threads across all processes and comparing to this limit reveals headroom before hitting 'can't create thread'/'resource temporarily unavailable' errors, which commonly surface first in thread-heavy applications like JVM-based services or connection-per-thread servers, well before other resource limits are reached.
Total threads and usage
total_threads = process_count × avg_threads_per_process; usage% = total_threads / threads_max × 100
The kernel auto-calculates a default at boot based on available RAM (roughly proportional to total pages divided by a per-thread-stack-size factor), so systems with more RAM get a higher default ceiling automatically. It can be overridden directly via `sysctl -w kernel.threads-max=<value>` if the workload needs more.
Attempts to create new threads or processes (both go through the same underlying clone() mechanism and consume from the same limit) fail, typically surfacing as 'fork: retry: Resource temporarily unavailable' or similar errors in applications, even if CPU and memory both still have headroom.
`ps -eLf | wc -l` counts all threads across all processes (each row is one thread), and `cat /proc/sys/kernel/threads-max` alongside `ps -eLf | wc -l` lets you compute current usage percentage directly rather than relying on estimated averages.