How to choose the right MPM for Apache?

The best Apache MPM depends on your application stack and traffic needs: 1. Use Prefork if relying on non-thread-safe modules like mod_php and prioritizing stability. 2. Use Worker for moderate to high traffic with thread-safe setups and better memory efficiency. 3. Use Event for high concurrency and modern setups with PHP-FPM or reverse proxies, as it efficiently handles persistent connections. Always pair the MPM with a compatible backend—preferably PHP-FPM for Event or Worker—and disable mod_php when not using Prefork to ensure optimal performance and stability.

Choosing the right Multi-Processing Module (MPM) for Apache is crucial for performance, scalability, and stability. Apache supports different MPMs to handle incoming requests, and the best choice depends on your server’s hardware, traffic patterns, and application requirements. Here’s how to pick the right one.

Understand the Main MPMs

Apache offers several MPMs, but the three most common are:

• Prefork
• Worker
• Event

Each handles requests differently in terms of processes and threads.

1. Prefork MPM – Best for Legacy or Non-Thread-Safe Software

• Uses multiple child processes, each handling one connection at a time.
• No threading – each process is single-threaded.
• Highly stable and compatible with non-thread-safe modules (e.g., mod_php).

✅ Use Prefork if:

• You’re using older PHP (via mod_php) or other non-thread-safe modules.
• You prioritize stability over high concurrency.
• Your server has limited RAM but handles moderate traffic.

⚠️ Downsides:

• High memory usage (each process is memory-heavy).
• Not ideal for high-traffic sites.

2. Worker MPM – Balanced Performance with Threads

• Uses a mix of processes and threads.
• Each process can spawn multiple threads, each serving a request.
• More memory-efficient than Prefork.

✅ Use Worker if:

• You want better concurrency and lower memory usage.
• You’re using thread-safe modules (e.g., PHP-FPM instead of mod_php).
• Your traffic is moderate to high.

⚠️ Downsides:

• Some modules may not be thread-safe.
• Less stable than Prefork under certain conditions.

3. Event MPM – Best for High Concurrency and Modern Setups

• A variant of Worker, optimized for long-lived connections (like KeepAlive).
• Uses a dedicated thread to manage idle connections, freeing up workers.
• Designed for high-performance, high-traffic environments.

✅ Use Event if:

• You expect high concurrency (many simultaneous users).
• You’re using PHP-FPM or a reverse proxy (e.g., with Node.js or Python apps).
• You want efficient handling of idle or persistent connections.

⚠️ Downsides:

• Can be tricky to tune.
• May have issues with certain older modules (e.g., mod_php).

Consider Your Application Stack

The MPM must align with how your backend works:

• Using mod_php (DSO)? → Stick with Prefork.
• Using PHP-FPM with FastCGI? → Go for Event or Worker.
• Serving static content or reverse-proxying? → Event is ideal.

? Most modern setups use PHP-FPM Nginx or Apache in reverse-proxy mode, but if you're using Apache as the main web server, pairing Event MPM with PHP-FPM gives excellent performance.

Check Your OS and Apache Version

• Event MPM is stable in Apache 2.4 but was experimental in earlier versions.
• On Debian/Ubuntu, apache2 usually defaults to Event if PHP is not loaded as a module.
• On RHEL/CentOS, check with:

  httpd -V | grep 'MPM'

How to Switch MPMs (Debian/Ubuntu Example)

Apache usually allows only one MPM enabled at a time.

# Check current MPM
apache2ctl -V | grep 'MPM'

# Switch to event (if not already)
sudo a2dismod mpm_prefork
sudo a2enmod mpm_event

# If using PHP, disable mod_php and use FPM
sudo a2dismod php
sudo apt install php-fpm
sudo a2enconf php-fpm

# Restart Apache
sudo systemctl restart apache2

Tune the MPM Settings

After choosing, adjust directives in the MPM config file (e.g., /etc/apache2/mods-available/mpm_event.conf):

<IfModule mpm_event_module>
    StartServers             3
    MinSpareThreads         75
    MaxSpareThreads        250
    ThreadLimit             64
    ThreadsPerChild         25
    MaxRequestWorkers      400
    MaxConnectionsPerChild 1000
</IfModule>

Adjust based on:

• Available RAM: MaxRequestWorkers × memory_per_process ≈ total_memory_used
• Expected traffic: higher traffic → higher MaxRequestWorkers
• KeepAlive usage: Event handles this better than Worker or Prefork

Bottom line:
For most modern, high-performance Apache servers, Event MPM PHP-FPM is the best combo.
Stick with Prefork only if you depend on non-thread-safe modules.
Worker is a middle ground but largely superseded by Event.

Basically, match the MPM to your backend setup and traffic needs — and always disable mod_php if you’re not using Prefork.

The above is the detailed content of How to choose the right MPM for Apache?. For more information, please follow other related articles on the PHP Chinese website!