Fibers for concurrency in PHP - Deep Dive

Overview - Fibers for concurrency

What is it?

Fibers in PHP are a way to pause and resume code execution at specific points, allowing multiple tasks to run in an interleaved manner without blocking each other. They let you write code that looks like normal sequential code but can switch between tasks efficiently. This helps manage concurrency, which means doing many things at once, without the complexity of threads or processes. Fibers are like lightweight helpers that keep track of where you left off in your code.

Why it matters

Without fibers, PHP scripts run one thing at a time, waiting for each task to finish before starting the next. This can make programs slow, especially when waiting for things like network responses or file reads. Fibers let PHP handle multiple tasks smoothly, improving performance and responsiveness. This means websites and apps can feel faster and handle more users without complicated setups.

Where it fits

Before learning fibers, you should understand basic PHP syntax, functions, and how PHP runs code sequentially. Knowing about callbacks or promises helps but is not required. After fibers, you can explore asynchronous programming in PHP, event loops, and libraries that use fibers for efficient concurrency.

Mental Model

Core Idea

Fibers let you pause a task and switch to another, then come back exactly where you left off, enabling smooth multitasking without real threads.

Think of it like...

Imagine reading several books at once. You read a few pages of one book, then put a bookmark and switch to another book. Later, you return to the first book and continue from the bookmark. Fibers work like those bookmarks in your code.

┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│ Fiber A     │──────▶│ Paused at   │       │ Resumed at  │
│ (Task 1)    │       │ suspend()   │──────▶│ suspend()   │
└─────────────┘       └─────────────┘       └─────────────┘
       ▲                                         │
       │                                         ▼
┌─────────────┐       ┌─────────────┐       ┌─────────────┐
│ Fiber B     │──────▶│ Paused at   │       │ Resumed at  │
│ (Task 2)    │       │ suspend()   │──────▶│ suspend()   │
└─────────────┘       └─────────────┘       └─────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Sequential PHP Execution

Concept: PHP normally runs code one line after another without interruption.

In PHP, when you write code, it executes from top to bottom. Each command waits for the previous one to finish before starting. For example, if you ask PHP to read a file and then print a message, it will wait until the file is fully read before printing.

Result

Code runs step-by-step, no multitasking happens.

Understanding that PHP runs code sequentially helps see why concurrency needs special tools like fibers.

2

Foundation

What is Concurrency and Why It Matters

Concept: Concurrency means handling multiple tasks by switching between them, making programs faster and more responsive.

Imagine cooking multiple dishes at once. You start one, then while it simmers, you chop vegetables for another. You switch tasks to use your time well. Computers do the same with concurrency, running parts of different tasks by switching quickly.

Result

Programs can do more work in less time, improving speed and user experience.

Knowing concurrency's goal prepares you to understand how fibers help PHP multitask.

3

Intermediate

Introducing Fibers: Pause and Resume Code

🤔Before reading on: do you think fibers create new threads or just manage code flow? Commit to your answer.

Concept: Fibers let you pause a function and resume it later without creating new threads or processes.

PHP fibers are objects that run a function until it reaches a pause point (called suspend). At that point, the fiber stops, saving its state. Later, you can resume the fiber, and it continues from where it paused. This lets you switch between multiple fibers, simulating multitasking.

Result

You can run multiple tasks in an interleaved way without real parallel threads.

Understanding fibers as code flow managers, not threads, clarifies their lightweight and efficient nature.

4

Intermediate

Basic Fiber Usage in PHP

🤔Before reading on: do you think fibers automatically switch between tasks or require manual control? Commit to your answer.

Concept: Fibers require explicit commands to start, suspend, and resume execution.

To use fibers, you create a Fiber object with a function. You start it with start(), which runs until it suspends with Fiber::suspend(). You can then resume it with resume(). This manual control lets you decide when to switch tasks.

Result

You can write code that pauses and resumes, enabling cooperative multitasking.

Knowing fibers need manual switching helps avoid confusion about automatic multitasking.

5

Intermediate

Cooperative Multitasking with Fibers

🤔Before reading on: do you think fibers preemptively switch tasks or rely on tasks to yield? Commit to your answer.

Concept: Fibers use cooperative multitasking, meaning tasks must voluntarily pause to let others run.

Unlike threads that can be interrupted anytime, fibers run until they call suspend(). This means each fiber cooperates by yielding control, allowing smooth switching without conflicts or race conditions.

Result

Tasks run smoothly without unexpected interruptions, making concurrency easier to manage.

Understanding cooperative multitasking prevents mistakes expecting fibers to preempt tasks automatically.

6

Advanced

Using Fibers for Asynchronous I/O

🤔Before reading on: do you think fibers handle I/O operations themselves or just manage code flow? Commit to your answer.

Concept: Fibers help write asynchronous code that waits for I/O without blocking the whole program.

When a fiber waits for a network or file operation, it can suspend itself. Meanwhile, other fibers run. Once the I/O is ready, the waiting fiber resumes. This lets PHP handle many I/O tasks efficiently without freezing.

Result

Programs can handle many slow operations concurrently, improving performance.

Knowing fibers separate waiting from blocking helps write efficient asynchronous PHP code.

7

Expert

Internal Fiber State and Context Switching

🤔Before reading on: do you think fibers share the same call stack or have separate stacks? Commit to your answer.

Concept: Fibers maintain their own call stack and execution context, enabling precise pause and resume.

Each fiber has its own stack and local variables. When suspended, PHP saves this state. Resuming restores it exactly, so the fiber continues as if uninterrupted. This lightweight context switching is faster than OS threads and avoids complex locking.

Result

Fibers provide efficient multitasking with minimal overhead and safe state management.

Understanding fibers' separate stacks explains their speed and safety compared to threads.

Under the Hood

Fibers work by saving the current execution state, including the call stack and local variables, when they suspend. PHP's engine stores this state internally. When resumed, PHP restores the state and continues execution from the exact point of suspension. This is done without creating new OS threads or processes, making fibers lightweight. The switching is cooperative, meaning fibers yield control explicitly, avoiding complex synchronization.

Why designed this way?

Fibers were introduced to provide concurrency in PHP without the complexity and overhead of threads or external event loops. PHP is traditionally synchronous and single-threaded, so fibers offer a way to write asynchronous code in a familiar style. The cooperative design avoids race conditions and locking issues common in preemptive multitasking. This design balances simplicity, performance, and safety.

┌───────────────┐          ┌───────────────┐          ┌───────────────┐
│ Fiber Created │─────────▶│ Running Fiber │─────────▶│ Fiber Suspends│
│ (Function)    │          │ (Executes)    │          │ (State Saved) │
└───────────────┘          └───────────────┘          └───────────────┘
       ▲                          │                            │
       │                          ▼                            ▼
┌───────────────┐          ┌───────────────┐          ┌───────────────┐
│ Fiber Resumed │◀─────────│ State Restored│◀─────────│ Scheduler or  │
│ (Continue)    │          │ (Call Stack)  │          │ User Control  │
└───────────────┘          └───────────────┘          └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do fibers create new operating system threads? Commit to yes or no.

Common Belief: Fibers are just like threads and create new OS threads to run code concurrently.

Reality: Fibers do not create new OS threads; they run within the same thread and switch execution cooperatively.

Why it matters: Believing fibers are threads can lead to expecting automatic parallelism and thread safety issues, causing bugs and confusion.

Quick: Do fibers automatically switch between tasks without programmer control? Commit to yes or no.

Common Belief: Fibers automatically manage task switching without any manual intervention.

Reality: Fibers require explicit calls to suspend and resume; they do not preemptively switch tasks.

Why it matters: Expecting automatic switching can cause programs to hang or not run as intended because fibers never yield control.

Quick: Can fibers run truly in parallel on multiple CPU cores? Commit to yes or no.

Common Belief: Fibers run code in parallel on multiple CPU cores like threads do.

Reality: Fibers run on a single thread and do not provide true parallel execution across CPU cores.

Why it matters: Misunderstanding this can lead to performance assumptions that fibers cannot fulfill, requiring other tools for parallelism.

Quick: Are fibers a replacement for all asynchronous programming models? Commit to yes or no.

Common Belief: Fibers replace all other asynchronous programming techniques and make them obsolete.

Reality: Fibers complement but do not replace event loops or promises; they provide a different way to write asynchronous code.

Why it matters: Thinking fibers replace everything can cause misuse or ignoring better-suited async models for certain tasks.

Expert Zone

1

Fibers share the same global state and variables, so careful management is needed to avoid side effects when switching contexts.

2

Stack size for fibers is limited and smaller than OS threads, which can cause stack overflow if deeply nested calls occur inside a fiber.

3

Fibers can be combined with event loops to build powerful asynchronous frameworks, but require careful coordination to avoid deadlocks.

When NOT to use

Fibers are not suitable when true parallelism is required, such as CPU-bound tasks needing multiple cores. In those cases, use multi-threading extensions or separate processes. Also, fibers are not ideal if automatic preemptive multitasking is needed, where threads or async frameworks with event loops are better.

Production Patterns

In production, fibers are often used with asynchronous I/O libraries to write readable code that handles many network requests concurrently. Frameworks use fibers to simplify callback hell and improve maintainability. They are also used in coroutine-based schedulers where fibers represent lightweight tasks cooperatively managed.

Connections

Coroutines

Fibers are a form of coroutines that allow cooperative multitasking by pausing and resuming execution.

Understanding fibers as coroutines helps grasp their role in managing asynchronous code flow without threads.

Operating System Threads

Fibers differ from OS threads by being lightweight and cooperative rather than preemptive and heavy.

Knowing the difference clarifies when to use fibers versus threads for concurrency.

Human Task Switching

Fibers mimic how humans switch between tasks by pausing and resuming work consciously.

Recognizing this connection helps appreciate the cooperative nature of fibers and why they avoid conflicts common in preemptive multitasking.

Common Pitfalls

#1 Expecting fibers to run code in parallel automatically.

Wrong approach:

$fiber = new Fiber(function() { /* long task */ });
$fiber->start();
// Expecting other code to run simultaneously without suspending fiber

Correct approach:

$fiber = new Fiber(function() {
// do part of task
Fiber::suspend();
// resume task
});
$fiber->start();
// Run other code
$fiber->resume();

Root cause:

Misunderstanding that fibers require explicit suspension to allow multitasking.

#2 Not suspending fibers, causing blocking behavior.

Wrong approach:

$fiber = new Fiber(function() {
// long running loop without suspend
for ($i = 0; $i < 1000000; $i++) {
// no suspend
}
});
$fiber->start();

Correct approach:

$fiber = new Fiber(function() {
for ($i = 0; $i < 1000000; $i++) {
if ($i % 1000 === 0) {
Fiber::suspend();
}
}
});
$fiber->start();

Root cause:

Not realizing fibers must yield control to enable concurrency.

#3 Trying to resume a fiber that is not suspended.

Wrong approach:

$fiber = new Fiber(function() {
echo 'Hello';
});
$fiber->start();
$fiber->resume(); // Error: fiber not suspended

Correct approach:

$fiber = new Fiber(function() {
Fiber::suspend();
echo 'Hello';
});
$fiber->start();
$fiber->resume();

Root cause:

Misunderstanding fiber lifecycle and when resume() can be called.

Key Takeaways

Fibers let PHP pause and resume code execution, enabling cooperative multitasking without threads.

They require explicit suspension and resumption, giving programmers control over task switching.

Fibers run in a single thread and do not provide true parallelism but improve concurrency for I/O-bound tasks.

Understanding fibers' separate call stacks explains their efficiency and safety compared to threads.

Fibers complement other asynchronous models and are powerful tools for writing readable, efficient concurrent PHP code.