Understanding PHP 8.1 Fibers: Concepts, Usage, and Practical Examples

PHP 8.1 introduces Fibers, a powerful tool that gives developers fine‑grained control over concurrency by allowing code execution to be paused and resumed without the overhead of full threads or processes. Fibers enable more efficient, non‑blocking applications, improving performance and responsiveness.

What are Fibers?

Fibers are lightweight concurrency primitives in PHP that support cooperative multitasking. They let a function suspend execution at a specific point and later resume from that point, which is especially useful for I/O‑intensive tasks such as database queries or HTTP requests. Unlike traditional blocking code, Fibers allow developers to avoid unnecessary waiting, thereby boosting application speed.

How Fibers Work

In PHP, Fibers are implemented via the Fiber class. Defining a Fiber creates a function that can be started, suspended, and resumed.

$fiber = new Fiber(function () {
    echo "Start of fiber\n";
    Fiber::suspend(); // pause here
    echo "Resume fiber\n";
});

echo "Before fiber start\n";
$fiber->start(); // runs until suspend
echo "After fiber start, before resume\n";
$fiber->resume(); // continues execution
echo "After fiber resume\n";

Output:

Before fiber start
Start of fiber
After fiber start, before resume
Resume fiber
After fiber resume

The start() method initializes and runs the Fiber until Fiber::suspend() is called; resume() continues execution from the suspension point.

Why Use Fibers?

Build non‑blocking code: avoid halting the main thread during I/O.

Improve performance by yielding control during long‑running operations.

Simplify asynchronous programming compared to callbacks or promises.

Practical Use Cases

Fibers shine in scenarios such as asynchronous I/O, concurrent request handling in custom PHP servers, and cooperative multitasking where developers manually schedule tasks.

Example: Mitigating I/O Blocking with Fibers

Traditional sequential code that fetches data from an API (2 s) and a database (3 s) takes 5 seconds total:

function fetchDataFromApi() { sleep(2); return "API Data"; }
function fetchDataFromDatabase() { sleep(3); return "Database Data"; }

$apiData = fetchDataFromApi();
$dbData = fetchDataFromDatabase();

echo "Processing data: $apiData and $dbData\n";

Using Fibers, the two operations can run in parallel, reducing total wait time to the longest individual task (3 seconds):

$fiberApi = new Fiber(function () {
    sleep(2);
    Fiber::suspend("API Data");
});
$fiberDb = new Fiber(function () {
    sleep(3);
    Fiber::suspend("Database Data");
});

echo "Fetching data...\n";
$fiberApi->start();
$fiberDb->start();
$apiData = $fiberApi->resume();
$dbData = $fiberDb->resume();

echo "Processing data: $apiData and $dbData\n";

Example: Non‑Blocking Large File Reading

A traditional file‑reading loop blocks the script until the entire file is read. By wrapping the read logic in a Fiber and suspending after each line, the main script can continue processing other work while the file is being read.

$fiber = new Fiber(function ($filePath) {
    $handle = fopen($filePath, 'r');
    if ($handle) {
        while (($line = fgets($handle)) !== false) {
            Fiber::suspend($line); // yield each line
        }
        fclose($handle);
    } else {
        Fiber::suspend("Error opening file.");
    }
});

echo "Starting file read...\n";
$fiber->start('largefile.txt');
while ($fiber->isStarted()) {
    $line = $fiber->resume();
    if ($line !== false) {
        echo $line; // process line
    }
}

echo "File read complete.\n";

Considerations and Limitations

Fibers are not a replacement for multithreading; they operate within a single thread.

They add complexity in managing state and control flow.

Only available on PHP 8.1 or newer.

Conclusion

I/O blocking remains a major challenge for PHP developers. PHP 8.1's Fibers provide a robust solution for writing efficient, non‑blocking code, enabling responsive and high‑performance applications, especially in I/O‑heavy environments.