Memory Management — Stack vs Heap

Also Known As

TL;DR

Explanation

Stack memory: allocated at function call, freed at return. Stores: local variables, function parameters, return addresses. Fixed size (typically 8MB on Linux). Extremely fast — just a pointer increment. Stack overflow: too many nested calls exhaust the stack. Heap memory: allocated with new/malloc, freed by garbage collection or explicit free. Stores: objects, arrays, large data structures. PHP uses a reference-counting GC with cycle collector. ZendMM (Zend Memory Manager) manages PHP's heap. PHP does not expose stack vs heap to the developer — all variables are reference-counted heap values by default.

Common Misconception

Why It Matters

Common Mistakes

• Circular references without unset() — PHP's refcount GC handles most cycles but cyclic destruction order can cause leaks.
• Appending to a huge array in a loop instead of using generators.
• Not calling unset() on large variables in long-running scripts.
• Using PHP's GC with long-lived objects — gc_collect_cycles() can be called manually for cycle collection.

Code Examples

// Memory leak via circular reference:
class Node {
    public ?Node $parent = null;
    public array $children = [];
}
$parent = new Node();
$child  = new Node();
$parent->children[] = $child;
$child->parent      = $parent; // Circular: parent→child→parent
unset($parent, $child); // Refcount never reaches 0 — leak!
// PHP cycle GC eventually collects these, but slowly

// Break circular references explicitly:
unset($child->parent); // Break cycle before unset
unset($parent, $child); // Now refcount reaches 0 immediately

// Or use WeakReference for back-references:
class Node {
    public ?\WeakReference $parent = null; // Does not increment refcount
}
$child->parent = \WeakReference::create($parent);
// When $parent is unset, WeakReference returns null — no cycle

References

• ↗ https://www.php.net/manual/en/features.gc.php

Tags

Related Terms