Encapsulated Concurrency Programming in PHP: Multi‑Process, Multi‑Thread, and Coroutine Examples

With the rapid growth of the Internet, high‑concurrency applications are increasingly common. PHP, a widely used server‑side language, is now entering the field of concurrent programming, where encapsulation plays a key role in managing and controlling concurrent operations.

Encapsulation means packaging a piece of functionality into an independent unit that can fulfill a specific task and adapt to various concurrent scenarios. In PHP, several approaches can be used to achieve encapsulated concurrent programming, as illustrated by the following examples.

Using Multi‑Process to Implement Concurrency

In PHP, the pcntl extension can be used to create multiple processes for concurrent execution. The example below demonstrates how to fork five child processes, each performing independent work.

<code><?php

$workers = [];
$workerNum = 5;

for ($i = 0; $i < $workerNum; $i++) {
    $pid = pcntl_fork();

    if ($pid == -1) {
        die("Fork failed");
    } else if ($pid == 0) {
        // worker process
        // do some work
        exit();
    } else {
        // parent process
        $workers[] = $pid;
    }
}

foreach ($workers as $pid) {
    pcntl_waitpid($pid);
}

?>
</code>

The pcntl_fork function creates five child processes; each child can execute its own concurrent task, allowing parallel processing of a large number of jobs and improving overall execution efficiency.

Using Multi‑Thread to Implement Concurrency

PHP can also achieve concurrency through the pthreads extension. The following code creates five threads, each running a separate task.

<code><?php

class MyThread extends Thread {
    public function run() {
        // do some work
    }
}

$threads = [];
$threadNum = 5;

for ($i = 0; $i < $threadNum; $i++) {
    $thread = new MyThread();
    $thread->start();
    $threads[] = $thread;
}

foreach ($threads as $thread) {
    $thread->join();
}

?>
</code>

The pthreads class creates five threads that can share memory, making resource management more efficient compared with separate processes.

Using Coroutine to Implement Concurrency

Another lightweight concurrency model in PHP is provided by the Swoole extension. The example below shows how to create five coroutines using the Coroutine class.

<code><?php

$coroutine = new Coroutine();

for ($i = 0; $i < 5; $i++) {
    $coroutine->create(function () {
        // do some work
    });
}

?>
</code>

The Swoole Coroutine class creates five lightweight coroutines, each capable of executing an independent concurrent operation. Coroutines provide an efficient way to boost a program's concurrent processing capacity.

Through these examples, it is clear that implementing encapsulated concurrent programming in PHP is straightforward. Depending on the specific requirements, developers can choose multi‑process, multi‑thread, or coroutine approaches to achieve high‑performance concurrent execution.