CentOS7服务器PHP-CLI脚本内存占用优化方案咨询

Hey there! Let's break down practical ways to cut memory usage for your PHP CLI scripts on that memory-constrained CentOS 7 server—since you’ve got multiple users firing off these scripts, every MB counts. Below are actionable tools and methods, plus a call on whether they’re worth your time:

1. 启用OPcache（低成本高回报） #

Even though you’re running CLI scripts, OPcache can still work magic here—by default, OPcache is disabled for CLI, so enabling it lets PHP cache the script’s bytecode instead of parsing the 4KB file every single time. This cuts down on repeated memory overhead from script compilation.

To set it up:

• Edit your CLI-specific php.ini (usually at /etc/php-cli.ini or under /etc/php.d/)
• Add/update these settings:

  opcache.enable_cli = 1
  opcache.memory_consumption = 16  # 16MB is way more than enough for your tiny script
  opcache.max_accelerated_files = 1000  # Only need to cache your single script + core files
  

This alone can shave off a few MB per script instance, especially if users run the script frequently.

2. 精简PHP配置与扩展 #

Default PHP installs often load a ton of unused extensions that eat up memory. Since your script only uses mysqli and curl, strip out everything else:

• Go to /etc/php-cli.d/ (the directory for CLI-specific extensions)
• Rename or comment out .conf files for extensions you don’t need (e.g., gd.conf, soap.conf, imagick.conf)
• Also, tweak the memory_limit to match your actual usage: set it to 12M or 15M (since your script uses ~10MB) instead of the default (which might be 128M or even unlimited). Add this to php-cli.ini:

  memory_limit = 12M
  

This prevents PHP from reserving more memory than necessary for each script run.

3. 复用PHP进程（更高复杂度，更大节省） #

Instead of spawning a new PHP process for every user’s script execution, reuse existing processes to avoid reloading the PHP core and extensions every time. Two ways to do this:

Option A: Use PHP-FPM for CLI requests #

Configure PHP-FPM to handle CLI-like requests via FastCGI. Users can call your script through PHP-FPM instead of the php command. For example:

• Set up PHP-FPM with an ondemand or dynamic process manager (edit /etc/php-fpm.d/www.conf):

  pm = ondemand
  pm.max_children = 10  # Adjust based on your server's total memory
  pm.process_idle_timeout = 10s
  

• Users run a command like this instead of php script.php:

  cgi-fcgi -bind -connect /var/run/php-fpm/www.sock < script.php
  

This lets PHP-FPM reuse processes, cutting the per-request memory footprint drastically.

Option B: Build a resident worker process #

Write a simple PHP daemon that runs continuously, listens for task requests (via a local socket, pipe, or even a simple file queue), and executes your script’s logic. Users send their task parameters to this daemon instead of starting a new PHP process.

For example, the daemon could look like this (simplified):

#!/usr/bin/env php
<?php
// Keep the process running
while (true) {
    // Listen for incoming task requests (e.g., read from a named pipe)
    $task = read_task_from_queue();
    if ($task) {
        // Execute your script's logic here
        run_script_logic($task);
    }
    // Sleep briefly to avoid hogging CPU
    usleep(100000);
}

This way, you only load PHP + required extensions once (using ~10MB total), and all user requests reuse this single process.

4. 编译定制版PHP（进阶） #

If you’re comfortable compiling PHP from source, build a stripped-down version that only includes the extensions you need (mysqli and curl). This removes all unused core features and extensions, making the PHP binary smaller and reducing memory overhead.

The configure command would look something like:

./configure --enable-mysqli --with-curl --disable-all --enable-cli

Then compile and install—this gives you a minimal PHP build tailored exactly to your needs.

值得做吗？ #

It depends on how tight your server’s memory is:

• If memory is scarce (e.g., 512MB or 1GB total): Absolutely. Start with the low-effort wins first (OPcache, trimming extensions/memory_limit)—these take 10 minutes to set up and will immediately reduce memory usage. If that’s not enough, move to process reuse (PHP-FPM or resident workers).
• If memory is relatively abundant: The low-effort tweaks are still worth doing—they reduce memory fragmentation and leave more headroom for other tasks. The more complex process reuse might be overkill unless you’re seeing frequent memory pressure.

内容的提问来源于stack exchange，提问作者MixMix