Why PHP Memory Grows in Long‑Running Workers and How to Fix It

In web development, PHP typically runs as short‑lived scripts handling HTTP requests, so memory usage appears negligible. However, when PHP is used for long‑running workers (e.g., background jobs, queue consumers, daemons), memory consumption can gradually rise and eventually cause out‑of‑memory errors. This increase is linked to PHP's memory‑management model, resource leaks in code, and garbage‑collection behavior.

1. PHP Memory Management Mechanism

PHP manages memory using reference counting combined with a garbage‑collector (GC). In short‑lived scripts, all variables and resources are destroyed at script termination, releasing memory. In long‑running processes, memory is not automatically reset unless variables are explicitly freed or GC is triggered. Circular references or large objects that are not promptly released cause memory to accumulate.

2. Common Memory Leak Causes

Typical reasons for memory growth in long‑running PHP processes include:

Circular references: objects that reference each other may not be reclaimed promptly, especially because the GC runs infrequently by default.

Unreleased resources: open database connections, file handles, or cached data that are not properly closed continue to occupy memory.

Accumulating globals or static variables: data added repeatedly to globals or static storage persists for the lifetime of the process.

Third‑party libraries or extensions with memory‑management bugs that surface during extended execution.

3. Impact of Garbage Collection

The GC can be invoked manually with gc_collect_cycles(). By default, GC runs only when the root buffer is full, not on every variable destruction. In long‑running processes that generate many circular references, GC may not run often enough, leading to rising memory usage. Developers can adjust the gc_probability and gc_divisor settings or call the GC periodically to mitigate the issue.

4. Practical Example and Debugging

Consider a worker that processes queue jobs and loads a large data set on each iteration. If the loaded data is not released, memory will keep growing:

while (true) {
    $data = fetchLargeData(); // fetch a large payload each loop
    processData($data);
    // $data is never unset, memory usage climbs
}

Remedies include explicitly setting $data = null or calling unset($data). Monitoring functions such as memory_get_usage() help track consumption, while tools like Xdebug or Valgrind can profile memory behavior.

5. Solutions and Best Practices

To keep memory usage under control in long‑running PHP processes, adopt the following practices:

Periodically restart workers: use a process manager (e.g., Supervisor) to limit execution count or memory usage and automatically restart processes.

Write memory‑friendly code: avoid globals, release unused resources promptly, and minimize circular references.

Adjust GC behavior: manually invoke gc_collect_cycles() inside loops or increase GC frequency via configuration.

Prefer memory‑efficient extensions: for large data handling, use ext‑json instead of json_decode where appropriate.

Log and monitor memory: record usage metrics to detect leaks early and act before they affect stability.

Conclusion

Memory growth in long‑running PHP workers stems from the language's reference‑counting model, unreleased resources, and infrequent garbage collection. By understanding GC mechanics, cleaning up variables, tuning GC settings, and employing process restarts and efficient extensions, developers can maintain stable memory footprints, which is crucial for micro‑services and high‑concurrency environments.