PHP Academy · Les

PHP 8.1 Fibers

Pauzeer en hervat de uitvoering met native Fibers.

Les 2 van 413 stappen

PHP 8.1 Fibers 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.

Wat Fibers je bieden

PHP 8.1 voegde Fibers toe: een primitive in de kern waarmee je een actieve aanroepstack kunt pauzeren en later vanaf een volledig andere plek kunt hervatten. Een Fiber is een volledige, onafhankelijke stack die je op een willekeurig punt kunt onderbreken en daarna kunt voortzetten zonder de stack af te wikkelen. Dit is het ontbrekende onderdeel waarmee bibliotheken beloftenketens kunnen vervangen door een synchroon uitziende await — de basis van de moderne API's van ReactPHP en Amp.

Je eerste Fiber

Maak een Fiber met een callback, start deze met start() en laat deze zichzelf pauzeren met suspend(). De besturing keert op het punt van de onderbreking terug naar de aanroeper; resume() gaat precies vanaf daar verder.

<?php
$fiber = new Fiber(function (): void {
    echo "A: inside fiber\n";
    $received = Fiber::suspend('paused');
    echo "C: resumed with '$received'\n";
});

$value = $fiber->start();          // prints A, returns 'paused'
echo "B: fiber suspended, got '$value'\n";
$fiber->resume('hello');           // prints C
echo "D: fiber done\n";

De vier kernmethoden

De API is klein:

$fiber->start(...$args) — begint de uitvoering en retourneert de eerste waarde waarmee de Fiber wordt gepauzeerd.
Fiber::suspend($value) — pauzeert de huidige Fiber en geeft $value aan de code die deze hervat.
$fiber->resume($value) — gaat verder; $value wordt de retourwaarde van suspend().
$fiber->getReturn() — de retourwaarde van de callback nadat deze is beëindigd.

Waarden gaan in beide richtingen over de onderbrekingsgrens.

Waarden in twee richtingen doorgeven

Een Fiber kan een verzoek naar buiten doorgeven en vervolgens een antwoord terug ontvangen — de kern van de manier waarop een eventlus I/O-resultaten aan gepauzeerde taken doorgeeft.

<?php
$fiber = new Fiber(function (): int {
    $a = Fiber::suspend('need first number');
    $b = Fiber::suspend('need second number');
    return $a + $b;
});

$fiber->start();        // suspends: 'need first number'
$fiber->resume(10);     // a = 10, suspends: 'need second number'
$fiber->resume(32);     // b = 32, fiber returns
echo $fiber->getReturn(), PHP_EOL; // 42

Toestand en introspectie van een Fiber

Je kunt een Fiber vragen naar zijn levenscyclus. Als je resume() aanroept op een beëindigde Fiber, wordt FiberError gegenereerd. Gebruik daarom deze controles wanneer je een scheduler bouwt.

<?php
$fiber = new Fiber(function () { Fiber::suspend(); });
var_dump($fiber->isStarted());     // false
$fiber->start();
var_dump($fiber->isStarted());     // true
var_dump($fiber->isSuspended());   // true
var_dump($fiber->isRunning());     // false (we're outside it)
$fiber->resume();
var_dump($fiber->isTerminated());  // true

Een kleine scheduler bouwen

Fibers plus een wachtrij vormen een coöperatieve scheduler. Elke taak pauzeert om de besturing over te dragen; de scheduler behandelt de taken beurtelings totdat ze allemaal klaar zijn. Dit is het skelet binnen elke asynchrone runtime.

<?php
$tasks = [];
foreach (['X', 'Y', 'Z'] as $name) {
    $tasks[] = new Fiber(function () use ($name) {
        for ($i = 1; $i <= 2; $i++) {
            echo "$name step $i\n";
            Fiber::suspend();   // give others a turn
        }
    });
}
foreach ($tasks as $t) { $t->start(); }
while ($tasks) {
    foreach ($tasks as $k => $t) {
        if ($t->isTerminated()) { unset($tasks[$k]); continue; }
        $t->resume();
    }
}

Uitzonderingen over grenzen heen

throwInto() (in de API throw() genoemd als $fiber->throw()) voegt een uitzondering in op het punt waar de Fiber is gepauzeerd — zo meldt een lus een mislukte I/O-bewerking aan de taak die erop wacht. De uitzondering wordt precies zichtbaar op de plek waar de Fiber was gepauzeerd.

<?php
$fiber = new Fiber(function () {
    try {
        Fiber::suspend();
    } catch (RuntimeException $e) {
        echo 'caught: ' . $e->getMessage() . PHP_EOL;
    }
});
$fiber->start();
$fiber->throw(new RuntimeException('io failed')); // prints: caught: io failed

Fibers versus Generators

Generators (yield) kunnen ook pauzeren — maar alleen de bovenste functie. Om vanuit een geneste helper te wachten met generators, moet je yield from helemaal naar boven in de aanroepstack doorgeven, waardoor elke functie daaraan moet worden aangepast. Fibers pauzeren de volledige stack vanaf elke diepte, zodat een diep geneste aanroep Fiber::suspend() kan uitvoeren zonder dat de aanroepers hiervan op de hoogte zijn. Daarom kan await een gewone functieaanroep zijn in plaats van een yield.

<?php
function deep(): string {
    // No yield needed in the call chain — suspends the whole fiber
    return Fiber::suspend('awaiting from deep');
}
$f = new Fiber(fn() => print(deep() . PHP_EOL));
$f->start();
$f->resume('value injected at depth');

De beperking voor pauzeren

Er geldt één harde regel: je kunt Fiber::suspend() alleen binnen een Fiber aanroepen. Pauzeren vanuit de hoofdthread, of via een callback op C-niveau die Fibers niet ondersteunt (sommige verouderde usort-vergelijkers en bepaalde interne callbacks), genereert FiberError: Cannot suspend outside of a fiber. Bibliotheken verbergen dit door ervoor te zorgen dat alle gebruikerscode binnen een Fiber draait die door de lus wordt aangestuurd.

<?php
try {
    Fiber::suspend(); // main thread — illegal
} catch (FiberError $e) {
    echo $e->getMessage(), PHP_EOL; // Cannot suspend outside of a fiber
}

Hoe bibliotheken Fibers gebruiken

In toepassingscode schrijf je zelden rechtstreeks met Fibers. Raamwerken zoals Amp v3 en ReactPHP (via fibers) wikkelen ze in: await($promise) roept intern Fiber::suspend() aan, registreert een voortzetting bij de eventlus en hervat je Fiber met resume() zodra de I/O-bewerking is voltooid. Je code ziet eruit als synchrone code; de runtime regelt het pauzeren en plannen.

<?php
// Conceptual: what an await() helper does under the hood
function await(Promise $p): mixed {
    $fiber = Fiber::getCurrent() ?? throw new Error('await() outside fiber');
    $p->then(fn($v) => $fiber->resume($v),
             fn($e) => $fiber->throw($e));
    return Fiber::suspend(); // parked until the promise settles
}

Kanttekeningen bij geheugen en levenscyclus

Elke Fiber reserveert zijn eigen stack, dus honderdduizenden Fibers starten kost geheugen (hoewel ze veel lichter zijn dan threads van het besturingssysteem). Een Fiber die voor altijd is gepauzeerd, wordt nooit door de garbage collector opgeruimd als iets er nog naar verwijst — een subtiel lek in langlopende servers. Ook wordt een niet-afgevangen uitzondering uit de callback van een Fiber doorgegeven vanuit de aanroep van resume()/start(), dus de scheduler moet hervattingen met try/catch omwikkelen.

<?php
$fiber = new Fiber(function () {
    throw new RuntimeException('boom inside fiber');
});
try {
    $fiber->start(); // exception surfaces here, at the resumer
} catch (RuntimeException $e) {
    echo 'scheduler caught: ' . $e->getMessage() . PHP_EOL;
}

Snelle controle

Welk belangrijk voordeel hebben Fibers voor asynchroon programmeren ten opzichte van generators?

Beantwoord dit in de interactieve les

Samenvatting

Fibers zijn PHP's primitive voor gelijktijdigheid op laag niveau:

start(), Fiber::suspend(), resume() en getReturn() pauzeren en hervatten een volledige aanroepstack, waarbij waarden in beide richtingen worden doorgegeven.
Methoden voor de toestand (isSuspended, isTerminated) en throw() laten je een coöperatieve scheduler bouwen en I/O-fouten invoegen.
In tegenstelling tot generators pauzeert een Fiber vanaf elke diepte — waardoor een transparante await() mogelijk wordt.
Je kunt alleen binnen een Fiber pauzeren; raamwerken zoals Amp en ReactPHP wikkelen Fibers in, zodat je asynchrone code synchroon leest.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “PHP 8.1 Fibers” gratis?

Ja — de volledige tekst van “PHP 8.1 Fibers” 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 “PHP 8.1 Fibers”?

Pauzeer en hervat de uitvoering met native Fibers. 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 “PHP 8.1 Fibers”?

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

← Terug naar PHP Academy