Boost PHP Performance with Thread Pools and Coroutines: Full Code Guide

In PHP programming, thread pools and coroutines are important methods to improve performance and concurrency. This article introduces how to implement thread pools and coroutines at the PHP lower level and provides concrete code examples.

Thread Pool Implementation

A thread pool reuses threads to boost the performance of multithreaded applications. In PHP, multithreading can achieve concurrent execution of multiple tasks, enhancing the program's concurrency capability. Below is a simple PHP thread‑pool implementation example:

class ThreadPool {
    private $pool;
    private $maxThreads;

    public function __construct($maxThreads) {
        $this->maxThreads = $maxThreads;
        $this->pool = new SplQueue();
    }

    public function run($task) {
        if (count($this->pool) < $this->maxThreads) {
            $thread = new Thread($task);
            $thread->start();
            $this->pool->enqueue($thread);
        } else {
            while (count($this->pool) >= $this->maxThreads) {
                usleep(1000);
            }
            $this->run($task); // recursive call until a thread is free
        }
    }

    public function wait() {
        while (!$this->pool->isEmpty()) {
            $thread = $this->pool->dequeue();
            $thread->join();
        }
    }
}

class Thread extends Thread {
    private $task;

    public function __construct($task) {
        $this->task = $task;
    }

    public function run() {
        // execute task
        call_user_func($this->task);
    }
}

$pool = new ThreadPool(5);
for ($i = 0; $i < 10; $i++) {
    $task = function() use ($i) {
        echo "Task " . $i . " is running in thread " . Thread::getCurrentThreadId() . "
";
        usleep(1000000);
        echo "Task " . $i . " is completed
";
    };
    $pool->run($task);
}
$pool->wait();

In the code above, the ThreadPool class maintains the pool of threads, allowing up to $maxThreads threads to run simultaneously. The Thread class encapsulates a specific task and starts it with the start method.

Running the example shows that the thread pool can execute up to $maxThreads tasks at once, fetching the next task after one finishes.

Coroutine Implementation

A coroutine is a lightweight thread that can pause and resume execution at different points. In PHP, coroutines enable highly scalable and high‑concurrency applications. Below is a simple PHP coroutine implementation example:

function coroutine() {
    $task = (yield); // get first task
    while ($task) {
        call_user_func($task);
        $task = (yield); // get next task
    }
}

// example
$coroutine = coroutine();
$coroutine->send(function() {
    echo "Task 1 is running
";
    usleep(1000000);
    echo "Task 1 is completed
";
});
$coroutine->send(function() {
    echo "Task 2 is running
";
    usleep(1000000);
    echo "Task 2 is completed
";
});

In this code, the coroutine function defines a coroutine that uses the yield keyword to pause and resume execution. The send method sends tasks to the coroutine, with each task defined as a regular function.

Running the example demonstrates that the coroutine executes the sent tasks sequentially, continuing with the next task after each one completes.

Conclusion

PHP’s low‑level thread pools and coroutines provide a high‑performance, high‑concurrency programming model. Thread pools enable multithreaded concurrent task execution, while coroutines allow highly scalable and concurrent applications, improving system performance and throughput.