Demystifying Coroutines: From Blocking to Non‑Blocking Execution in PHP and Go

The author, a Golang/Python developer with a PHP background, shares a practical understanding of coroutines, aiming to clarify common misconceptions and illustrate how coroutines simplify concurrent programming.

Blocking vs. Non‑Blocking

Using everyday analogies, the article defines blocking as a task that occupies the entire workflow (e.g., personally buying oranges), while non‑blocking delegates the task to another party (e.g., ordering delivery), allowing the original thread to continue other work. Non‑blocking still involves some blocking during the delegation step and consumes more resources (additional workers).

Processes and Threads

To achieve concurrency, systems rely on processes or threads. In PHP, multi‑process models (e.g., workerman/webman) are common, using fork to create separate workers, each handling its own logic.

What Is a Coroutine?

A coroutine is a programming construct that enables cooperative multitasking by allowing code to be paused and resumed. It consists of three parts:

Coroutine itself

Coroutine scheduler

Coroutine executor

In some languages, coroutines are called fibers; PHP’s fiber and yield represent stackful and stackless coroutines respectively. Coroutines do not provide true parallelism; they merely enable interruption and resumption of execution.

Why Use Coroutines?

Thinking in a purely blocking way limits concurrency. By adopting a non‑blocking mindset, tasks can be broken into smaller units and scheduled across multiple “delivery workers,” improving overall throughput. The scheduler decides which coroutine runs next, similar to time‑slice scheduling.

Scheduling and Execution

The scheduler allocates execution slots to coroutines, possibly using multiple threads or processes. Different languages implement various scheduling rules, often involving time‑slicing.

Extended Questions

How to handle dependencies between small tasks when some may be delegated?

In Go, system calls are bound to a specific thread and cannot be migrated, whereas network polling (netpoll) may be handed off to other threads. Context objects can act as tickets, guiding the scheduler on execution priority.

What if the main thread finishes before coroutine responses arrive?

The answer is a wait‑group pattern: each delegated task records a counter; the main thread loops until the counter reaches zero, indicating all coroutines have completed.

Implementing Coroutines in PHP

PHP typically uses multi‑process models, which are resource‑heavy and cumbersome for coroutine‑style concurrency. By introducing an event‑loop, PHP can register coroutine executors and a scheduler, mimicking Go’s systemcall approach. However, this adds complexity to the event loop.

Simple Analogy

Think of a coroutine system as a tiny queue: Program A publishes messages (coroutines), Program B schedules them (queue service), and Program C consumes them, notifying the source upon completion—all within a single thread or process, exploiting idle time.