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

In PHP programming, thread pools and coroutines are key techniques for enhancing performance and concurrency. The article first introduces a simple thread‑pool implementation.

Thread Pool Implementation

The ThreadPool class manages a pool of reusable threads, limiting the maximum number of concurrent threads with the $maxThreads property. It uses an SplQueue to store idle threads and provides run() to submit tasks and wait() to block until all tasks finish.

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);
        }
    }
    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() { 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();

The example shows the pool executing up to five tasks simultaneously, queuing additional tasks until a thread becomes free.

Coroutine Implementation

Coroutines provide lightweight, pause‑and‑resume execution. The article presents a basic coroutine function using yield to receive tasks and call_user_func to execute them.

function coroutine() {
    $task = (yield);
    while ($task) {
        call_user_func($task);
        $task = (yield);
    }
}

$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
";
});

The coroutine processes tasks sequentially, pausing after each yield and resuming when send() supplies the next task.

Conclusion

Both low‑level thread pools and coroutines give PHP developers powerful models for high‑performance, high‑concurrency applications. Thread pools enable parallel execution of multiple tasks, while coroutines offer lightweight, scalable handling of asynchronous workflows, improving overall system throughput.