A PHP variable's lifecycle begins with memory allocation via zval creation, which stores the value, type, reference count, and reference flag. 2. When variables are assigned or shared, PHP uses reference counting and copy-on-write to optimize memory usage, only duplicating data when necessary. 3. At scope exit or after unset(), the reference count decreases, and if it reaches zero, memory is immediately freed. 4. For circular references where reference counts never reach zero, PHP’s cyclic garbage collector identifies and cleans up unreachable cycles. 5. Memory is eventually returned to the system or reused, ensuring efficient resource management throughout the variable’s lifecycle.

A PHP variable doesn’t just appear out of thin air — it goes through a well-defined lifecycle from the moment you assign it a value to the moment PHP cleans it up. Understanding this lifecycle helps you write more efficient, predictable code and debug memory issues more effectively. Let’s walk through how PHP handles variables under the hood, from creation to cleanup.

Variable Creation and Memory Allocation

When you write something like:

$number = 42;

PHP doesn’t just store the value — it allocates memory for a zval (Zend value), the internal structure that holds all information about a variable.

A zval contains:

• The actual value (e.g., 42)
• The type (e.g., IS_LONG)
• A reference count (used for reference counting)
• A flag indicating whether it’s a reference or not

At this point, the reference count is set to 1 because one variable ($number) points to this zval.

This allocation happens in PHP’s userland memory space, managed by Zend Engine. The exact location (stack or heap) depends on context — local variables in functions may live on the stack, while complex or long-lived values go on the heap.

Reference Counting and Copy-on-Write

PHP uses reference counting as its primary mechanism for tracking when a variable is no longer needed.

Let’s expand the example:

$a = "hello";
$b = $a;        // Both $a and $b point to the same zval

Now, the zval holding "hello" has a reference count of 2. But PHP doesn’t immediately make a full copy — it uses copy-on-write (COW) optimization.

If you later modify $b:

$b = "world";

PHP detects that the zval is shared and not actually referenced (i.e., not a true reference via &), so it creates a new zval for $b, decrements the old one’s count, and assigns the new value. This avoids unnecessary duplication and saves memory.

But if you do:

$b = &$a;

Now both variables are true references to the same zval. Modifying one affects the other, and the reference count increases — but more importantly, the is_ref flag is set, which changes how future assignments behave.

Scope and Unsetting: When References Drop

Variables naturally go out of scope when a function ends:

function greet() {
    $message = "Hi!";
    // $message exists
}
// $message is now out of scope

When the function exits, the symbol table for that scope is destroyed. Each variable in it decrements the reference count of its zval. If the count reaches zero, PHP can immediately free the memory.

You can also manually reduce the count with unset():

$a = [1, 2, 3];
unset($a); // Reference count drops; if no other refs, zval is freed

Note: unset() doesn’t necessarily free memory — it just removes the variable’s reference. If another variable (like $b = $a) shares the same zval, the count drops but the value persists.

Garbage Collection: Cleaning Up Cycles

Reference counting works well — until you hit circular references.

Example:

$a = [];
$b = [];
$a['b'] = $b;
$b['a'] = $a;

// Now unset both
unset($a, $b);

Even after unsetting, the two zvals still point to each other, so their reference counts are 1, not 0. They’re unreachable but not freed — a memory leak.

This is where PHP’s cyclic garbage collector steps in.

PHP runs a periodic garbage collection cycle (triggered manually with gc_collect_cycles() or automatically under certain conditions) that:

1. Looks for zvals with reference counts > 0 that are no longer reachable from the root symbol tables
2. Identifies cycles using a root buffer and a depth-first search
3. Frees the memory if a cycle is confirmed as garbage

You can control this behavior:

• gc_enable() / gc_disable() — toggle GC
• gc_collect_cycles() — force collection
• gc_status() — check runs, collected, memory usage

Summary: The Full Lifecycle

1. Allocation: A zval is created when you assign a value.
2. Usage: Variables may be shared via copy-on-write or true references.
3. Scope Exit / Unset: Reference count drops; if zero, memory is freed.
4. Cycle Detection: If reference count never hits zero due to cycles, the GC intervenes.
5. Cleanup: Memory is returned to the system (or kept for reuse in PHP’s memory manager).

Understanding this flow helps you avoid common pitfalls — like memory leaks from closures capturing objects, or unexpected sharing between variables. While PHP handles most of this automatically, knowing when and how variables die makes you a better PHP developer.

Basically: PHP is smart, but not magic.

The above is the detailed content of The Lifecycle of a PHP Variable: From Allocation to Garbage Collection. For more information, please follow other related articles on the PHP Chinese website!