Free tools Windows power users keep installed
One-click scans. No signup required.
There is no safe, universal Apache “high-traffic” number. A reliable configuration starts by choosing an MPM that matches your modules, measuring the server under representative concurrency, calculating a memory-safe MaxRequestWorkers, and then tuning keep-alive behavior so idle clients do not consume capacity needed by active requests. For most modern, threaded-safe installations, start by evaluating mpm_event; use mpm_worker when its simpler threaded model fits your workload, and retain mpm_prefork only when module compatibility or blocking application behavior requires it.
Need a server to try this on? Antihost offers Linux VPS plans with NVMe storage, full root access and a 14-day free trial.
What “high traffic” means in Apache
Apache becomes saturated when one of its finite resources is exhausted: request workers, CPU, memory, socket queues, file descriptors, or a downstream service such as PHP, a database, or an upstream proxy. A site can have modest requests per second and still fail if requests are slow or clients hold connections open. Conversely, a fast static workload may handle many requests with relatively few workers.
As an Amazon Associate I earn from qualifying purchases.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →MaxRequestWorkers is the upper limit on requests Apache serves simultaneously. When all workers are busy, additional connections normally wait in the accept queue, subject to the operating system and Apache’s ListenBacklog. Raising the limit without enough memory or CPU can increase queueing, trigger swapping, prevent Apache from starting, or destabilize the host. Apache’s documentation does not publish a universal requests-per-second capacity or a one-size-fits-all worker value.
Choose the right multi-processing module (MPM)
The MPM determines how Apache creates processes and threads. Make this decision before adjusting worker counts; otherwise, a value that is valid for one MPM may be ignored or impossible under another.
#1 Best Overall
- Read Before You Buy — No Video Output: These adapters support charging and USB 2.0 data transfer, but cannot transmit video signals. Except for standard USB webcams (which use USB data only), they are not compatible with HDMI/DisplayPort cables, video-capable USB-C hubs, or docking stations with video output.
- Convert USB-A Ports to USB-C: Designed to connect USB-C earphones, cables, flash drives, card readers, and other USB-C accessories to standard USB-A ports. Plug-and-play with no drivers or software required.
- Aluminum Alloy Housing: Built with a sturdy aluminum alloy shell that aids in heat dissipation and protects against daily wear and scratches. Designed to maintain a stable and secure connection.
- Compact & Travel-Friendly: The ultra-compact design allows the adapter to stay plugged into your device without blocking adjacent ports or adding bulk, reducing wear and tear on your original USB ports.
- 12-Month Warranty: Backed by a 12-month manufacturer warranty for peace of mind. Designed to meet strict quality control standards for reliable everyday performance.
| MPM | Concurrency model | Where it fits | Important trade-offs |
|---|---|---|---|
event |
Processes with worker threads plus an event-driven listener path | High concurrency with threaded-safe modules, especially when many clients keep connections idle | Requires every loaded module and application integration to be safe in a threaded model; blocking or long-running work still consumes request workers |
worker |
Processes containing multiple request threads | Threaded-safe deployments that need a smaller memory footprint than prefork | Idle keep-alive connections still affect the threaded capacity more directly than with event; module compatibility remains essential |
prefork |
One request-serving process per worker, without request threads | Legacy or non-thread-safe modules and applications that require process isolation | Higher memory use per concurrent request; large concurrency can exhaust RAM sooner |
Apache’s performance guidance describes worker as a good high-traffic choice because it generally has a smaller memory footprint than prefork. The event MPM uses a threaded design but passes some connection-management work to listener threads, allowing request workers to serve new work while many clients are idle in keep-alive.
When event is not automatically the answer
Check every third-party module, embedded interpreter, authentication provider, and application connector. A single non-thread-safe component can force prefork. Also consider request shape: a proxy request waiting on a slow upstream, a dynamic request holding a database connection, a TLS handshake, or a multi-gigabyte upload can occupy resources for much longer than a static file response. Benchmark the real mix rather than selecting an MPM from a benchmark for a different workload.
Establish a baseline before changing limits
Run a representative load test against a staging host or a controlled production window. The test should include the same TLS settings, compression, application calls, cache state, request sizes, and client connection behavior expected at peak.
- Record throughput, p95 and p99 latency, HTTP status errors, and timeout rates.
- Record CPU utilization, memory usage and peak resident set size (RSS), swap activity, open file descriptors, and established connections.
- Observe Apache’s worker scoreboard and queueing with
mod_status. - Measure dependent services separately; an Apache worker increase cannot repair a saturated database or upstream application pool.
Change one material setting at a time, retain the previous configuration, and define a rollback trigger such as rising p99 latency, increasing 5xx responses, swapping, or a growing accept queue.
Confirm the active MPM and module compatibility
Use the command supplied by your distribution to list loaded modules, then verify that exactly one MPM is active:
# Debian and Ubuntu
apache2ctl -M | grep mpm
# RHEL, Rocky, AlmaLinux and similar systems
httpd -M | grep mpmThe output should identify one of mpm_event_module, mpm_worker_module, or mpm_prefork_module. On Debian-family systems, switching commonly uses a2dismod and a2enmod; review the package’s dependency checks before disabling an MPM. On other systems, edit the vendor-provided LoadModule configuration rather than copying a Debian command.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Rank #2
- 5-in-1 USB-C Hub: Experience comprehensive connectivity featuring a Power Delivery input, two USB-A 2.0 ports, a USB-A 3.0 port, and an HDMI port. (Note: The USB-C power delivery input port is only for connecting an external wall charger to power your laptop and cannot power peripheral devices.)
- 90W Pass-Through Charging: Achieve optimal charging with 90W pass-through power to your laptop, supported by a total input of 100W, with the hub reserving 10W for operational efficiency. (Note: Wall charger not included.)
- Quick Data Transfers: Accelerate your productivity with rapid data transfers using a high-speed 5Gbps USB 3.0 port and two 480Mbps USB 2.0 ports.
- 4K HDMI Display: Enhance your visual experience with a hub capable of delivering 4K resolution at 30Hz in both mirror and extend modes. Please note that this hub is compatible with MacBook (macOS 12 and newer), Windows 10 and 11, ChromeOS, and laptops equipped with DP Alt Mode and Power Delivery. Note: This device is not compatible with Linux.
- What You Get: Anker USB-C Hub (5-in-1, 4K HDMI), welcome guide, 18-month warranty, and our friendly customer service.
Inventory dynamically loaded modules and application handlers. A threaded MPM is appropriate only when those components document thread safety. Validate syntax and perform a graceful restart after every change:
apache2ctl configtest # or: httpd -t
apache2ctl graceful # or: httpd -k gracefulIf the syntax test fails or the process does not restart cleanly, restore the last known-good file before continuing.
Calculate a defensible MaxRequestWorkers value
Start with the memory budget, not a copied configuration. Reserve memory for the operating system, filesystem cache, logging, monitoring, TLS libraries, databases, application workers, and a safety margin. Then measure Apache’s peak memory footprint during a representative test.
A practical upper bound is:
MaxRequestWorkers ≤ floor(
(RAM available to Apache − OS/other-services reserve − safety margin)
÷ memory required per concurrent worker slot
)For prefork, measure the RSS of a busy child process and account for copy-on-write sharing; use peak values, not an idle process. For worker and event, include the shared process baseline, thread stacks, module allocations, and the memory used by active requests. If requests allocate substantially different amounts, size for a high percentile of observed usage rather than the average.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesFor example, if testing establishes a 3 GB Apache budget and a measured 60 MB worst-case worker slot, the arithmetic ceiling is 51 slots (floor(3072/60)). That is a planning calculation, not a guaranteed safe production value: leave headroom for bursts and verify the result under load.
Align the threaded MPM limits
In worker and event, ServerLimit, ThreadLimit, and ThreadsPerChild constrain the values Apache can represent. The effective worker capacity is the number of child processes multiplied by ThreadsPerChild, bounded by the configured limits. Set these directives deliberately so the product can represent your target MaxRequestWorkers, but do not set process or thread ceilings far above what the machine can sustain.
Rank #3
- Sleek 7-in-1 USB-C Hub: Features an HDMI port, two USB-A 3.0 ports, and a USB-C data port, each providing 5Gbps transfer speeds. It also includes a USB-C PD input port for charging up to 100W and dual SD and TF card slots, all in a compact design.
- Flawless 4K@60Hz Video with HDMI: Delivers exceptional clarity and smoothness with its 4K@60Hz HDMI port, making it ideal for high-definition presentations and entertainment. (Note: Only the HDMI port supports video projection; the USB-C port is for data transfer only.)
- Double Up on Efficiency: The two USB-A 3.0 ports and a USB-C port support a fast 5Gbps data rate, significantly boosting your transfer speeds and improving productivity.
- Fast and Reliable 85W Charging: Offers high-capacity, speedy charging for laptops up to 85W, so you spend less time tethered to an outlet and more time being productive.
- What You Get: Anker USB-C Hub (7-in-1), welcome guide, 18-month warranty, and our friendly customer service.
| Directive | Role | Documented default or constraint |
|---|---|---|
MaxRequestWorkers |
Maximum simultaneous requests | Prefork default is 256 in current Apache mpm_common documentation; threaded values depend on the MPM and configuration |
ThreadsPerChild |
Threads created in each child process | 25 for worker and event in current documentation |
MinSpareThreads |
Minimum idle threads Apache tries to keep available | 75 for worker and event |
MaxSpareThreads |
Upper target for idle threads before Apache retires some | 250 for worker and event |
ServerLimit |
Maximum child processes that can be configured | Must be high enough to express the desired worker total, but excessive values waste address space or prevent startup |
ThreadLimit |
Maximum thread count permitted per child | Must be at least as high as ThreadsPerChild; avoid setting it far beyond need |
The event MPM’s AsyncRequestWorkerFactor defaults to 2 in Apache’s 2.5 development documentation. Treat that value as version-specific: confirm the directive and default for the Apache release you actually run before changing it.
Illustrative threaded configuration
The following shows how the directives relate; the numbers are an arithmetic example, not a universal recommendation. A measured capacity of 16 child processes with 25 threads each would represent 400 request workers.
<IfModule mpm_event_module>
ServerLimit 16
ThreadLimit 25
ThreadsPerChild 25
MinSpareThreads 75
MaxSpareThreads 250
MaxRequestWorkers 400
</IfModule>Use the same relationship with mpm_worker. If your memory calculation supports fewer workers, lower MaxRequestWorkers and the process/thread limits accordingly. If the required number cannot be represented without exceeding memory, the answer is to reduce concurrency demand, improve request latency, add capacity, or move work to a more suitable tier—not to raise the limits indefinitely.
Tune keep-alive as a capacity trade-off
KeepAlive avoids a new TCP (and, for HTTPS, TLS) setup for every request, reducing latency and connection overhead. The cost is that idle clients retain sockets and can consume concurrency or file descriptors. Apache’s performance guide uses a five-second KeepAliveTimeout default to limit that cost and cautions against raising it above about 60 seconds without evidence.
Keep keep-alive enabled when clients make multiple requests over a short interval. Begin with the default five seconds, then compare connection reuse, handshake CPU, idle-connection counts, and tail latency. Shorten the timeout when idle clients crowd out active work; lengthen it only when measurements show that repeated handshakes are the bottleneck and the server has spare capacity.
The event MPM changes the economics: many idle keep-alive sockets can be managed asynchronously by listener threads instead of occupying request workers. It does not make slow application requests free; a worker remains busy while processing a blocking request.
Rank #4
- Dual Converters, Infinite Potential：Includes 2× USB C male to USB A female adapters and 2× USB A male to USB C female adapters. Perfect for a wide range of uses—tablets with Bluetooth keyboards, expand USB ports on macbook, and more. Two different converters for all your daily needs
- Next-Level 10Gbps & 3A Charging: No more slow 480Mbps, this usb to usb c adapter has a transfer speed of up to 10Gbps, allowing you to do more transferring in less time. This usb adapter fits both USB A and USB C charger, supporting up to 3A fast charging
- Upgraded Exquisite Craftsmanship: With an aluminum alloy housing and metal connector, the usbc to usb adapter is extremely durable and sturdy. Rigorously tested to withstand more than 10,000 times of plugging and unplugging, ensuring long-lasting performance
- Broad Compatible: The usb c to usb adapter widely supports all USB C/ USB A devices like laptops, tablets, cellphones, car chargers, and phone chargers. Such as compatible with MacBook Pro/Air 2023/2022, Thunderbolt 4/3 Devices,Apple MagSafe Watch 9/8/7/SE/Ultra, iPad Pro 2022/2021, Samsung Galaxy S23/S20/S10, and iPhone 17/16/15 Pro. Plug and play
- Please Note: To reach 10Gbps speed, keep the cable under 3.3 ft. For USB A Male to USB C adapters, try flipping the USB C connector. USB C Male to USB A adapters support bidirectional 10Gbps transfer within 3.3 ft
KeepAlive On
KeepAliveTimeout 5Set a finite KeepAliveTimeout and test with the actual client population. Proxies, mobile networks, HTTP/2 behavior, and large uploads can produce connection patterns that differ substantially from a simple HTTP benchmark.
Expose mod_status safely and use it to find saturation
mod_status reports worker states, request counts, and bytes served. Restrict it to a trusted administration network; never leave a detailed status endpoint open to the public internet.
ExtendedStatus On
<Location "/server-status">
SetHandler server-status
Require ip 192.0.2.0/24
</Location>The address above is documentation space; replace it with your management subnet. Apply the equivalent access-control syntax for your Apache version and authentication layer.
During a load test, correlate the scoreboard with host metrics:
Recommended Free Tools
- All request workers busy while CPU and memory remain healthy: requests are likely blocked on an upstream, disk, lock, or external API. Increasing workers may only amplify downstream pressure.
- All workers busy with rising CPU and stable latency: CPU is the limiting resource; optimize handlers, caching, compression, or TLS before raising concurrency.
- Growing idle keep-alive counts with few active requests: reduce the timeout or move to event if your modules are thread-safe.
- High RSS, swap activity, or the kernel killing processes: lower
MaxRequestWorkersand investigate per-request allocations. - Long queues with low Apache activity: inspect the listen backlog, file-descriptor limits, firewall, and upstream load balancer.
Use graceful restarts for normal configuration changes and watch the scoreboard afterward. A graceful restart lets existing requests finish, but a stream of long-running requests can delay replacement workers; schedule and monitor it accordingly.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Adapt the limits to workload shape
Static files and cache hits
Short responses usually release workers quickly. Focus on socket and TLS overhead, efficient caching, file descriptors, and a keep-alive timeout that matches client behavior. Event can improve concurrency when many clients remain connected between requests.
Best Value
- 5-in-1 Connectivity: Equipped with a 4K HDMI port, a 5 Gbps USB-C data port, two 5 Gbps USB-A ports, and a USB C 100W PD-IN port. Note: The USB C 100W PD-IN port supports only charging and does not support data transfer devices such as headphones or speakers.
- Powerful Pass-Through Charging: Supports up to 85W pass-through charging so you can power up your laptop while you use the hub. Note: Pass-through charging requires a charger (not included). Note: To achieve full power for iPad, we recommend using a 45W wall charger.
- Transfer Files in Seconds: Move files to and from your laptop at speeds of up to 5 Gbps via the USB-C and USB-A data ports. Note: The USB C 5Gbps Data port does not support video output.
- HD Display: Connect to the HDMI port to stream or mirror content to an external monitor in resolutions of up to 4K@30Hz. Note: The USB-C ports do not support video output.
- What You Get: Anker 332 USB-C Hub (5-in-1), welcome guide, our worry-free 18-month warranty, and friendly customer service.
Dynamic application requests
Match Apache concurrency to the application pool and database capacity. If the application supports only a fixed number of concurrent jobs, setting Apache far higher creates a queue in the wrong place and increases memory use. Measure end-to-end latency and upstream wait time.
Proxying and long-running requests
Streaming responses, slow upstreams, server-sent events, WebSocket integrations, and report generation hold workers for long periods. Separate these paths where possible, enforce appropriate upstream and client timeouts, and calculate worker capacity from the longest realistic occupancy rather than average request time.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
TLS and large uploads
TLS handshakes consume CPU; large uploads consume connection time, buffers, and often disk. Test handshake-heavy and upload-heavy scenarios separately from ordinary page traffic. A single worker limit cannot optimize both without considering their different resource profiles.
Roll out a change without losing control
- Record the current state. Save the active MPM, all MPM directives, keep-alive settings, module list, baseline metrics, and the exact package version.
- Choose a candidate MPM. Start with event when every relevant module is threaded-safe; otherwise evaluate worker or prefork for compatibility.
- Calculate a memory ceiling. Use measured peak RSS and reserve capacity for the operating system and other services.
- Align limits. Ensure
ServerLimit,ThreadLimit, andThreadsPerChildcan express the selectedMaxRequestWorkerswithout exceeding host capacity. - Set keep-alive deliberately. Keep it on when reuse helps, start with a finite timeout, and alter it only after observing idle connections and handshake cost.
- Validate configuration. Run
apache2ctl configtestorhttpd -t, then perform a graceful restart and confirm the intended MPM is loaded. - Load-test one variable. Compare throughput, p95/p99 latency, errors, CPU, RSS, open connections, and queueing with the baseline.
- Promote gradually. Watch logs and host metrics during a canary period. Revert immediately if memory pressure, queueing, or error rates worsen.
Troubleshoot common failure modes
| Symptom | Likely cause | Action |
|---|---|---|
| Apache fails to start after raising limits | ServerLimit, ThreadLimit, or process limits are invalid for the build or host |
Run the syntax test, read the error log, restore the previous values, and raise limits only as far as the selected MPM and memory budget require |
| RSS climbs until the host swaps | Too many prefork children or oversized threaded concurrency; per-request allocations are larger than measured | Lower MaxRequestWorkers, capture peak RSS under realistic requests, and fix leaks or downstream queuing |
| Requests queue while CPU is low | Workers are blocked on upstream services, locks, disk, or long client transfers | Profile request wait time, inspect upstream pools, and isolate long-running endpoints before adding workers |
| Many idle connections consume capacity | Keep-alive timeout is too long for client behavior, or a non-event MPM is handling many idle sockets | Reduce KeepAliveTimeout, verify client reuse, and evaluate event only after module compatibility review |
| Latency rises after increasing workers | Concurrency is overwhelming CPU, memory bandwidth, a database, or an application pool | Roll back, identify the saturated dependency, and coordinate limits across all tiers |
| Connections reset during bursts | Listen backlog, file descriptors, load balancer limits, or kernel queues are exhausted | Inspect operating-system connection metrics and descriptor limits; do not treat MaxRequestWorkers as the only queue |
What a defensible production configuration looks like
A defensible configuration names its MPM, module-compatibility decision, memory budget, measured worker footprint, target concurrency, keep-alive rationale, and rollback threshold. It also documents the Apache release because defaults and directives can change between stable and development documentation. The current Apache documentation lists a prefork MaxRequestWorkers default of 256, worker and event spare-thread defaults of 75 and 250, and ThreadsPerChild of 25; those defaults are starting points, not capacity guarantees.
Use event when its threaded and asynchronous design matches your modules and workload, worker when you need a straightforward threaded MPM, and prefork when compatibility requires process-based isolation. Let measured memory, request occupancy, queueing, and downstream limits determine the final worker count. Keep-alive should reduce connection churn without allowing idle clients to monopolize scarce resources. Re-test after Apache, module, kernel, TLS, or application changes because each can alter the safe operating point.
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.
