Geheugenbeheer en garbage collection
Ontdek hoe zvals, refcounting en de GC werken.
Geheugenbeheer en garbage collection is een gratis PHP Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject PHP Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus PHP Academy bevat in totaal 4 lessen.
Hoe PHP geheugen beheert
PHP-waarden leven in zvals en worden voornamelijk beheerd met referentietelling, aangevuld met een cycli-verzamelaar voor wat referentietelling niet kan opruimen. Als je dit begrijpt, begrijp je geheugenlekken in langlopende workers, de kosten van kopieën en wanneer gc_collect_cycles() belangrijk is.
De zval
Een zval is de container voor elke PHP-waarde: een type-aanduiding plus een union voor de opslag van de waarde. Scalaire waarden (int, float, bool) worden op waarde in de zval opgeslagen en worden NIET via referentietelling beheerd. Complexe typen (string, array, object) verwijzen naar een structuur met referentietelling op de heap.
<?php
// debug_zval_refcount-style inspection via gc + count
$arr = [1, 2, 3];
$copy = $arr; // refcount of the array bumps, no data copy yet (CoW)
// Modifying triggers copy-on-write separation
$copy[] = 4;
var_dump($arr); // still [1,2,3]
var_dump($copy); // [1,2,3,4]
?>Referentietelling
Elke waarde met referentietelling houdt bij naar hoeveel zvals deze verwijzen. Toewijzen verhoogt de teller; een variabele verwijderen of het bereik verlaten verlaagt deze. Zodra de teller nul bereikt, wordt het geheugen onmiddellijk vrijgegeven — je hoeft niet op een GC-ronde te wachten. Het meeste PHP-geheugen wordt op deze manier teruggewonnen.
<?php
$a = str_repeat('x', 1000); // refcount 1 on the string
$b = $a; // refcount 2
unset($a); // refcount 1
unset($b); // refcount 0 -> freed instantly
echo "Refcounting frees deterministically\n";
?>Kopiëren bij schrijven
Toewijzen kopieert de gegevens niet; de gegevens worden gedeeld en de referentietelling wordt verhoogd (kopiëren bij schrijven). De daadwerkelijke duplicatie vindt pas plaats bij de eerste schrijfactie naar een gedeelde waarde. Hierdoor kost het doorgeven van grote arrays weinig totdat ze worden gewijzigd.
<?php
$big = range(1, 100000);
$shared = $big; // O(1): shared, refcount++
// Reads stay shared and cheap
echo count($shared), PHP_EOL;
// First write separates (copies) — now it costs O(n)
$shared[0] = -1;
echo $big[0], ' vs ', $shared[0], PHP_EOL; // 1 vs -1
?>Het probleem: cycli
Referentietelling alleen kan referentiecycli niet vrijgeven. Als object A een verwijzing naar B bevat en B terugverwijst naar A, bereiken hun tellers nooit nul, zelfs niet nadat je elke externe variabele hebt verwijderd — het geheugen lekt totdat de cycli-verzamelaar wordt uitgevoerd.
<?php
class Node { public ?Node $ref = null; }
$a = new Node();
$b = new Node();
$a->ref = $b; // a -> b
$b->ref = $a; // b -> a (cycle!)
unset($a, $b); // external refs gone, but internal cycle keeps refcount > 0
// The objects are unreachable but NOT yet freed by refcounting alone.
echo gc_collect_cycles() . " cycles collected\n";
?>De cycli-verzamelaar
PHP's GC implementeert een synchrone mark-and-sweep over wortels. Mogelijke cycluswortels (waarden waarvan de referentietelling is verlaagd maar niet nul werd) worden gebufferd. Wanneer de wortelbuffer vol raakt (standaard 10.000), wordt GC uitgevoerd: deze simuleert verlagingen, vindt werkelijk onbereikbare groepen en geeft ze vrij.
<?php
// GC status exposes the root buffer and run stats
for ($i = 0; $i < 3; $i++) {
$a = new stdClass();
$b = new stdClass();
$a->b = $b; $b->a = $a; // create a cycle
unset($a, $b); // becomes a GC root
}
print_r(gc_status());
?>GC beheren
Je kunt de verzamelaar aansturen: gc_disable()/gc_enable() schakelen deze in of uit, en gc_collect_cycles() dwingt een ronde af en geeft het aantal vrijgegeven waarden terug. Bij batchtaken waarbij doorvoer cruciaal is, schakelen mensen GC soms uit tijdens een strakke fase en verzamelen ze alles eenmaal aan het einde.
<?php
gc_disable(); // no automatic cycle collection
// ... heavy phase that creates and drops many cycles ...
for ($i = 0; $i < 1000; $i++) {
$x = new stdClass(); $y = new stdClass();
$x->y = $y; $y->x = $x; unset($x, $y);
}
$freed = gc_collect_cycles(); // reclaim all at once
gc_enable();
echo "Freed $freed objects\n";
?>Langlopende workers
In CLI-daemons, wachtrijconsumenten en Swoole/RoadRunner-workers wordt geheugen niet vrijgegeven door het opruimen na een verzoek — het proces blijft uren actief. Let op: statische caches die onbeperkt groeien, zich opstapelende cycli en niet-gesloten bronnen. Houd het gebruik bij met memory_get_usage(true) en start workers regelmatig opnieuw.
<?php
$peakStart = memory_get_usage(true);
// Simulate processing a batch of jobs
for ($job = 0; $job < 5; $job++) {
$payload = range(0, 10000);
// ... process ...
unset($payload);
}
printf("start: %d KB, peak: %d KB, now: %d KB\n",
$peakStart >> 10,
memory_get_peak_usage(true) >> 10,
memory_get_usage(true) >> 10
);
?>WeakReference en WeakMap
Gebruik WeakReference (8.0) en WeakMap (8.0) om gegevens bij een object te cachen of ermee te associëren zonder het object in leven te houden. Een vermelding in een WeakMap verhoogt de referentietelling van het sleutelobject niet. Het object kan daardoor worden verzameld en de vermelding wordt automatisch verwijderd — ideaal voor zijdetabellen met metagegevens die geen lek mogen veroorzaken.
<?php
$map = new WeakMap();
$obj = new stdClass();
$map[$obj] = 'metadata'; // does NOT keep $obj alive
echo count($map) . PHP_EOL; // 1
unset($obj); // object collectible -> entry removed
echo count($map) . PHP_EOL; // 0
?>Geïnterneerde tekenreeksen en onveranderlijke waarden
Letterlijke tekenreeksen in je broncode zijn geïnterneerd: ze worden één keer opgeslagen, gedeeld en tijdens het verzoek nooit via referentietelling beheerd of vrijgegeven. OPcache verplaatst geïnterneerde tekenreeksen en onveranderlijke (gecachte) op_arrays naar gedeeld geheugen tussen verzoeken. Daarom zijn letterlijke tekenreeksen in feite kosteloos te kopiëren.
Geheugenlimiet en geheugentoewijzer
PHP gebruikt zijn eigen emalloc-toewijzer (Zend Memory Manager) boven op de systeemtoewijzer en houdt het gebruik per verzoek bij tegenover memory_limit. Als de limiet wordt bereikt, ontstaat een fatale fout. true in memory_get_usage(true) rapporteert echte toegewezen blokken van het besturingssysteem, niet alleen wat je script op dat moment vasthoudt.
<?php
echo 'limit: ' . ini_get('memory_limit') . PHP_EOL;
echo 'emalloc usage: ' . memory_get_usage() . " bytes\n"; // ZendMM tracked
echo 'real usage: ' . memory_get_usage(true) . " bytes\n"; // from OS
?>Snelle controle
Waarom kunnen sommige objecten lekken als je alleen referentietelling gebruikt?
Samenvatting
PHP slaat waarden op in zvals; scalaire waarden worden op waarde opgeslagen, complexe typen worden op de heap toegewezen en via referentietelling beheerd, met kopiëren bij schrijven. Referentietelling maakt geheugen deterministisch vrij bij teller nul, maar kan cycli niet terugwinnen. Daarom wordt een synchrone mark-and-sweep-verzamelaar uitgevoerd wanneer de wortelbuffer vol raakt (of via gc_collect_cycles()). Gebruik WeakMap/WeakReference voor associaties zonder eigenaarschap en let bij langlopende workers op onbeperkte groei.
Leer PHP met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 49
- Lessen
- 195
Veelgestelde vragen
Is de les “Geheugenbeheer en garbage collection” gratis?
Ja — de volledige tekst van “Geheugenbeheer en garbage collection” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus PHP Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus PHP Academy bevat in totaal 4 lessen.
Wat leer ik in “Geheugenbeheer en garbage collection”?
Ontdek hoe zvals, refcounting en de GC werken. Je oefent met PHP Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met PHP Academy te beginnen?
Ervaring vooraf is niet nodig. PHP Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.
Hoe lang duurt de les “Geheugenbeheer en garbage collection”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over PHP Academy?
Ja. Elke les over PHP Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Hoe de Zend Engine werkt
- Geheugenbeheer en garbage collection
- OPcache en JIT-compilatie
- Een eenvoudige PHP-extensie schrijven in C