Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errorsApache usually creates child processes on purpose: the parent process is maintaining enough capacity for current and expected requests. Whether the number is excessive depends on the active Multi-Processing Module (MPM), your spare-capacity settings, measured concurrency, and available memory—not on the process count alone.
Antihost offers Linux VPS plans with full root access, unlimited traffic on a 1 Gbps port and a 14-day free trial.
The safe fix is to identify the MPM, inspect the error log and server-status, then tune one capacity limit at a time. Raising MaxRequestWorkers or ServerLimit without a memory budget can turn a normal capacity problem into swapping, failed starts, or an unstable host.
As an Amazon Associate I earn from qualifying purchases.
What Apache child processes do
Apache has a parent process that manages one or more generations of children. Children accept connections and handle requests according to the active MPM. The parent creates more children when the available idle capacity falls below the configured spare threshold and retires them when capacity is no longer needed.
That means a rising process count is not automatically a leak. It may indicate genuine traffic, a deliberately large idle cushion, a limit that is higher than the machine can safely support, or old children waiting for long-lived connections to finish.
#1 Best Overall
The MPM determines what a “worker” means
| MPM | Concurrency model | What a child process represents | How MaxRequestWorkers is counted |
Typical diagnostic implication |
|---|---|---|---|---|
| prefork | Process per request worker | Each child is a process that can serve a request | Maximum simultaneous requests and, effectively, maximum child processes | Process count maps closely to configured concurrency; memory per process is the primary constraint |
| worker | Processes containing multiple threads | A process contains ThreadsPerChild request threads |
Available request threads, not child-process count | Several processes may be required to provide the configured thread total |
| event | Threaded workers with event-driven keep-alive handling | A process contains request threads; idle keep-alive connections can be handled more efficiently | Available request threads | Old or graceful processes and slow connections can make the process list look inflated |
For worker and event, the approximate number of active children needed for a target worker total is MaxRequestWorkers ÷ ThreadsPerChild, rounded up and constrained by ServerLimit. The exact process count also reflects startup and spare-thread settings.
Why Apache creates more children
It is below the spare-process or spare-thread target
In prefork, StartServers controls the initial number of children. MinSpareServers is the minimum number of idle children Apache tries to keep available, while MaxSpareServers is the upper point at which excess idle children can be terminated. If idle children fall below the minimum, the parent starts more.
Apache does not necessarily create every missing child at once. The prefork documentation describes an exponential ramp under sustained shortage: “It will spawn one, wait a second, then spawn two, wait a second, then spawn four.” A busy server can therefore show a quickly increasing process count while Apache catches up with demand.
Worker and event use the corresponding spare-thread controls, including MinSpareThreads and MaxSpareThreads. A high minimum intentionally keeps more idle capacity. A low minimum can make Apache create children repeatedly whenever traffic arrives in bursts.
Real concurrency is high
Each simultaneous request consumes a worker slot. A traffic burst, slow application response, large downloads, or upstream services that respond slowly can keep slots occupied long enough for Apache to start additional capacity. A process count that rises during a sustained busy period may therefore be expected.
The common MPM documentation defines MaxRequestWorkers as the maximum number of simultaneous requests. Connections above that limit are normally queued. Queueing is a capacity signal: it tells you that Apache has reached its configured concurrency ceiling, but it does not by itself prove that the ceiling should be raised.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Configured limits exceed the host’s budget
ServerLimit is the hard upper bound on active child processes. In prefork, MaxRequestWorkers maps directly to the maximum number of children; the current Apache documentation lists a default of 256 for that case. Increasing beyond the relevant limit requires an appropriate ServerLimit.
Rank #2
- Used Book in Good Condition
For worker and event, ServerLimit must be large enough to provide the requested thread total at the selected ThreadsPerChild. A high limit does not force Apache to use every process, but it permits a configuration that may be far beyond the machine’s memory, file-descriptor, or application capacity.
The same documentation records maximum documented ServerLimit values of 20,000 for worker/event and 200,000 for prefork in Apache 2.4. Those are ceilings, not sensible operating targets. Copying a large number into a production configuration without measuring memory can prevent startup or destabilize the host.
Graceful restarts leave old children alive
A graceful restart starts a new generation while allowing old children to finish open connections. The event MPM documentation describes scoreboard slots occupied by processes in Graceful state. Slow clients, long downloads, WebSocket-like persistent sessions, and keep-alive connections can delay those children’s exit.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →During frequent reloads, the process list can contain new children doing work, idle children from the current generation, and old children waiting to drain. The total may look excessive even though each generation is progressing normally. Repeated graceful restarts can make the buildup persistent if connections never finish.
How the limits fit together
Prefork arithmetic
With prefork, one child is one process and one process handles one request at a time. MaxRequestWorkers is therefore both the maximum simultaneous request count and the effective child-process ceiling. StartServers, MinSpareServers, and MaxSpareServers determine how quickly Apache adds or removes idle children around that ceiling.
Prefork is straightforward to reason about, but every active child carries its own Apache and module memory. If a PHP or other application module is loaded into each child, its resident memory is multiplied by the number of processes. A setting that appears reasonable from CPU usage can still exhaust RAM.
Worker and event arithmetic
Worker and event divide concurrency among threads. If ThreadsPerChild is 25 and MaxRequestWorkers is 100, Apache needs capacity for roughly four child processes, subject to rounding and the configured ServerLimit. If the worker total is not an appropriate multiple of ThreadsPerChild, the final process can be only partly utilized.
Threaded MPMs can serve the same concurrency with fewer processes than prefork, which may reduce duplicated process memory. They also impose thread-safety requirements on loaded modules and still consume memory for each process and thread. Do not switch MPMs solely to make the process list smaller without verifying module compatibility and application behavior.
A safe troubleshooting sequence
1. Identify the active MPM and Apache version
Use the command supplied by your distribution. Common forms are:
apachectl -M | grep mpm
httpd -M | grep mpm
apachectl -v
httpd -vUse the command that exists on the system; some distributions call the binary apache2ctl rather than apachectl. Record whether the output names mpm_prefork_module, mpm_worker_module, or mpm_event_module, along with the version.
2. Read the error log before changing limits
Search the active Apache error log for messages containing:
MaxRequestWorkersor its older alias, where applicable- scoreboard exhaustion or insufficient scoreboard slots
- graceful restart, old generation, or child-exit messages
- repeated respawning, startup failure, or out-of-memory symptoms
A message that workers are being queued points to a reached concurrency limit. Messages about graceful children or old generations point instead to connection draining and restart behavior.
3. Inspect server-status
Enable mod_status only for trusted administrators and restrict its location appropriately. In the status page, compare:
- busy versus idle workers
- the process IDs and generation of each child
- children marked stopping or in Graceful state
- active requests, request duration, and keep-alive activity
- whether the scoreboard is full while CPU or memory remains available
This distinguishes demand from retention. Many busy workers suggest real concurrency; many idle workers suggest spare settings; many old or graceful workers suggest restart or connection-draining problems.
4. Record every related directive
Capture the effective values, including settings inherited from included configuration files:
Crashes, No Sound, or Screen Glitches?
Random freezes, missing sound and display glitches usually trace back to one bad driver. Find and replace yours safely.Free scan · under a minutePC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11StartServersMinSpareServersandMaxSpareServersfor preforkMinSpareThreadsandMaxSpareThreadsfor worker/eventThreadsPerChildMaxRequestWorkersServerLimitMaxConnectionsPerChild, if configured
Do not rely on a panel’s abbreviated display if a distribution has multiple included MPM files. Check the configuration Apache actually loads and validate syntax before reloading.
5. Measure memory per process and leave headroom
Measure resident memory for representative Apache children during normal and peak traffic. Include memory used by TLS, loaded modules, the application runtime, database clients, the operating system, and any other services on the host. A simple planning estimate is:
safe worker capacity × measured resident memory per child
+ operating-system and service headroom
≤ physical memory availableFor threaded MPMs, measure the process and thread footprint rather than assuming that a lower process count means proportionally lower memory use. The correct ceiling is the largest measured concurrency the host can sustain without swapping or starving other services.
6. Change one control, reload gracefully, and observe
Change only one related setting at a time. Validate the configuration, perform a graceful reload, and watch the error log, status page, memory pressure, request latency, and process generations. If the process count, queueing, or memory behavior worsens, revert the last change before testing another hypothesis.
Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Repair Windows errors before they cause bigger problemsFix Now →Choose the fix that matches the symptom
Idle prefork children fall below the minimum during traffic
Keep MinSpareServers proportional to the observed burst pattern rather than setting it arbitrarily high. If Apache is repeatedly ramping from too few idle children, a modest increase can reduce startup lag. Keep MaxSpareServers close enough to let excess idle children retire after the burst. Do not raise MaxRequestWorkers unless the measured memory budget supports more simultaneous processes.
MaxRequestWorkers is reached and memory remains available
Confirm in server-status that workers are genuinely busy and that requests are not simply blocked by a slow dependency. If the host has measured memory and file-descriptor headroom, increase MaxRequestWorkers cautiously. For prefork, raise ServerLimit as required when the new worker ceiling exceeds the existing process limit. For worker/event, ensure the new value can be provided by the selected ThreadsPerChild and available ServerLimit.
Best Value
- Used Book in Good Condition
The host is swapping or running out of memory
Lower MaxRequestWorkers and the spare settings to keep concurrency within the measured budget. Reduce per-process application cost where possible, and consider moving application execution to a separate process manager so Apache’s connection handling is not forced to carry the application’s full memory footprint. A lower request ceiling that preserves responsiveness is safer than a larger ceiling that triggers swapping or kills processes.
Event shows many graceful or old-generation processes
Do not raise ServerLimit first. Find out why old children cannot drain: inspect restart frequency, long-running requests, slow clients, persistent connections, and keep-alive duration. Correct the restart trigger or connection behavior, then confirm that old generations disappear after their connections close.
Free tools Windows power users keep installed
One-click scans. No signup required.
Worker/event values do not line up
Make MaxRequestWorkers an appropriate multiple of ThreadsPerChild when practical, and verify that ServerLimit is at least the number of processes required by that division. An inconsistent combination can leave capacity unavailable or cause Apache to reject the configuration. Recheck the arithmetic after every change.
How to tell normal behavior from a real fault
| Observation | Likely explanation | Next check |
|---|---|---|
| Process count rises with busy workers during a traffic burst | Normal capacity growth | Compare busy workers, request latency, and memory to the configured ceiling |
| Many idle children remain after a burst | High spare setting or slow retirement | Review the relevant spare directive and status generations |
| Workers are queued at the ceiling but memory is comfortable | Concurrency limit may be undersized | Verify request quality and dependency latency before raising the limit |
| Memory climbs, swap is used, or the kernel kills processes | Configured concurrency exceeds host capacity | Lower limits and reduce per-process application cost |
| Several generations contain graceful children | Frequent restarts or connections that do not drain | Inspect restart automation, long requests, and keep-alive behavior |
| Apache fails to start after a limit change | Invalid MPM arithmetic or a limit beyond the supported configuration | Restore the last working values, run a syntax check, and recalculate from measured capacity |
Prefork versus worker/event: what the process count tells you
| Decision axis | Prefork | Worker/event |
|---|---|---|
| Architecture | Separate child processes handle request concurrency | Multiple threads share each child process |
| Concurrency setting | MaxRequestWorkers is effectively the process ceiling |
MaxRequestWorkers is a thread ceiling; process count depends on ThreadsPerChild |
| Memory behavior | Application and module memory can be multiplied across many processes | Fewer processes can serve the same concurrency, but threads and shared modules still consume memory |
| Module compatibility | Accommodates modules that are not thread-safe | Requires thread-safe modules and application components |
| Graceful restart visibility | Old children can remain until connections finish | Event explicitly exposes graceful/old-generation behavior in the scoreboard, especially with persistent connections |
| Status interpretation | Process count closely tracks worker count | Process count alone is incomplete; inspect threads, busy/idle states, and generations |
Practical rules for stable tuning
- Start with measured concurrency, not a copied maximum.
- Treat
MaxRequestWorkersas a resource limit, not a performance score. - Keep spare settings high enough for known bursts but low enough to release unused memory.
- For worker/event, calculate process needs from
MaxRequestWorkersandThreadsPerChild, then checkServerLimit. - Investigate graceful generations and slow connections before permitting more processes.
- Leave capacity for the operating system, TLS, application runtime, database clients, and file descriptors.
- Use
server-statusand the error log together; either view alone can mislead you. - After each change, observe a complete traffic cycle that includes both the busy period and the quiet period.
Frequently Asked Questions
Does a high Apache child-process count always mean a leak?
No. It can be normal capacity management, a high spare setting, real concurrent traffic, or old children draining connections after a graceful restart. Check the active MPM, busy/idle workers, and process generations before treating it as a leak.
What does MaxRequestWorkers limit?
In prefork it limits simultaneous requests and effectively limits child processes. In worker and event it limits request threads; the required child-process count also depends on ThreadsPerChild and ServerLimit.
Should I raise ServerLimit when Apache creates many processes?
Only when the configured concurrency genuinely requires more child processes and the host has measured memory and file-descriptor headroom. A higher ServerLimit can permit an unstable configuration; it does not solve graceful-process buildup or slow clients.
Recommended Free Tools
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
