Multithreading and Concurrent Processing in PHP Applications

PHP can perform concurrent work, but the best approach depends on where it runs. Web applications usually use background job queues and worker processes. Command-line scripts can use operating-system processes with pcntl or controlled child processes with proc_open. True shared-memory threading is possible in limited CLI environments through the parallel extension, but it is not the usual design for PHP web applications.

PHP is commonly used with a request-based execution model: a web server sends a request to PHP, PHP runs the script, returns a response, and the request's script state ends. This differs from a long-running Java or C# application where one process often creates and manages many threads.

Concurrency means that more than one unit of work can make progress during roughly the same period. In PHP, this is commonly achieved with:

• Separate processes: Start several PHP worker processes. Each has its own memory.
• Background jobs and queues: Put slow work into a queue; dedicated workers process it outside the web request.
• Asynchronous I/O: While waiting for network or file operations, allow other I/O work to continue.
• Threads in CLI scripts: Use the parallel extension when a true threaded design is appropriate and supported.

A process does not normally remain in memory after its PHP script finishes. A child PHP process exits when its command completes. Problems arise when a process is deliberately long-running, blocked, stuck in a loop, or never reaped by its parent process.

For web applications, creating a new process for every small task is usually inefficient. A queue with a fixed number of workers provides controlled concurrency, retries, monitoring, and predictable resource use.

Think of a restaurant kitchen.

• A single PHP request is one cook preparing one order from start to finish.
• A process is another cook with a separate workspace and ingredients. The cooks can work at the same time, but they do not automatically share notes or tools.
• A job queue is the order rail. Web requests add orders; a fixed number of workers take orders from the rail.
• A thread is more like several cooks sharing one kitchen. They can share resources, but they must coordinate carefully to avoid collisions.

PHP applications usually choose separate worker processes and a queue because separate workspaces are safer and easier to scale.

For command-line PHP on Unix-like systems, pcntl_fork() creates a child process. The child does work and exits; the parent waits for it.

<?php

$pid = pcntl_fork();

if ($pid === -1) {
    throw new RuntimeException('Could not create child process.');
}

if ($pid === 0) {
    // Child process
    echo "Child: starting work\n";
    sleep(2);
    echo "Child: work complete\n";
    exit(0);
}

// Parent process
echo "Parent: created child process {$pid}\n";
pcntl_waitpid($pid, $status);
echo "Parent: child process has exited\n";

pcntl_fork() returns different values:

• -1: the fork failed.
• 0: this code is running in the child.

Consider this CLI example, which runs two tasks concurrently:

<?php

$tasks = ['resize-image', 'send-email'];
$children = [];

foreach ($tasks as $task) {
    $pid = pcntl_fork();

    if ($pid === 0) {
        echo "Starting {$task}\n";
        sleep(1);
        echo "Finished {$task}\n";
        exit(0);
    }

    $children[] = $pid;
}

foreach ($children as $pid) {
    pcntl_waitpid($pid, $status);
}

echo "All tasks are complete\n";

Execution flow:

1. The original PHP process begins the first loop.
2. For resize-image, it forks a child. The child prints a message, waits one second, finishes, and exits.
3. The parent continues immediately to and forks another child.

Common uses for PHP concurrency include:

• Image and video processing: Generate thumbnails or convert uploaded media outside the user's request.
• Email and notifications: Queue welcome emails, password alerts, and push notifications.
• Report generation: Build a large CSV, PDF, or analytics report in the background.
• Third-party API calls: Fetch data from multiple independent services concurrently, especially when each call spends time waiting for a network response.
• Data imports: Process batches of records with a controlled number of workers.
• Scheduled maintenance: Run cleanup, backups, or synchronization tasks through CLI workers or cron jobs.

A user-facing request should generally return quickly. Slow work should be handed to a background system rather than holding the HTTP connection open.

In production PHP applications, the most common pattern is queue-based background processing:

1. A controller receives a request, such as an image upload.
2. It stores the image and creates a job such as GenerateThumbnail.
3. The job is placed in a queue backed by Redis, a database, RabbitMQ, Amazon SQS, or another broker.
4. One or more long-running CLI workers pull jobs from the queue.
5. Workers record success, retry temporary failures, and send permanent failures to a failed-job store.

This design limits concurrency by running a configured number of worker processes. For example, four workers can process up to four independent jobs at once without spawning unlimited processes.

For independent HTTP calls inside one command, developers may use an async event-loop library or a multi-request client. For CPU-heavy work, separate worker processes are often a better fit because CPU work does not become faster merely by waiting asynchronously.

Use a guard clause before starting work when possible:

if ($filePath === '' || !is_file($filePath)) {
    throw new InvalidArgumentException('A valid file is required.');
}

This prevents workers from consuming resources on jobs that cannot succeed.

Starting unlimited child processes

This can exhaust memory, CPU time, file descriptors, or process limits:

// Do not do this.
foreach ($manyTasks as $task) {
    pcntl_fork();
}

Use a queue or a worker pool with a fixed concurrency limit.

Forgetting to collect child processes

A child can finish but remain listed as a zombie until its parent collects its status.

// In the parent, collect children.
pcntl_waitpid($pid, $status);

For multiple children, track their IDs and wait for each one.

Assuming variables are shared after fork()

After forking, parent and child have separate memory. Updating a variable in the child does not update it in the parent.

$count = 1;
$pid = pcntl_fork();

if ($pid === 0) {
    $count = 2;
    exit(0);
}

(, );
 ; 

// Create a child process (CLI, Unix-like systems)
$pid = pcntl_fork();

if ($pid === -1) {
    throw new RuntimeException('Fork failed');
}

if ($pid === 0) {
    // Child-only work
    exit(0);
}

// Parent-only work
pcntl_waitpid($pid, $status);

• Use pcntl for CLI tools, not standard web requests.
• A child process should finish naturally or call exit().
• The parent should call pcntl_waitpid() or pcntl_wait() to reap children.
• Parent and child do not share normal PHP variables after forking.
• Limit the number of concurrent workers.
• For HTTP applications, prefer queues and dedicated CLI workers.
• Use proc_open() when you need to start and manage an external command.
• Use explicit communication: queues, databases, pipes, sockets, or files.

Can PHP do multithreading?

PHP can run concurrent work in several ways. True threading is possible in limited CLI setups with extensions such as parallel, but process-based workers and job queues are more common for PHP applications.

Does a PHP child process remain in memory after the script ends?

Normally, no. A child exits when its PHP script reaches the end or calls exit(). The parent should still wait for it to collect its exit status.

What is a zombie process in PHP?

A zombie is a child process that has finished but whose parent has not collected its exit status. Call pcntl_waitpid() or pcntl_wait() in the parent.

Can I use pcntl_fork() in a Laravel or Symfony web controller?

It is generally not recommended. Put slow work in the framework's queue system and run workers as separate CLI processes.

How do parent and child PHP processes share data?

They do not share ordinary variables. Use a database, Redis, a message queue, sockets, pipes, or files to exchange data.

When should I use async I/O instead of worker processes?

Use async I/O when the work mostly waits for network or file operations. Use separate processes for CPU-heavy work or independently retryable background jobs.

Can PHP terminate a child process?

Yes, depending on how it was created and the platform. For example, a proc_open() child can be stopped with proc_terminate(). Graceful completion and reliable cleanup are preferable whenever possible.

• PHP CLI — process-management tools are primarily used from command-line scripts.
• Background job queues — the standard way to run slow tasks outside HTTP requests.
• Worker processes — long-running programs that consume jobs with controlled concurrency.
• pcntl_fork() — creates child processes on supported Unix-like systems.
• proc_open() — starts external commands with input, output, and lifecycle control.
• Asynchronous I/O — improves throughput for tasks that spend time waiting on I/O.
• Process communication — explains how isolated processes exchange data.
• Retries and idempotency — essential when background jobs can fail or run more than once.