Concorrência e paralelismo são conceitos essenciais na programação moderna, permitindo que aplicações executem múltiplas tarefas simultaneamente, seja por meio de execução intercalada (simultaneidade) ou execução simultânea (paralelismo). O PHP, conhecido principalmente por seu modelo de execução síncrona, evoluiu para suportar esses paradigmas por meio de diversas técnicas.

Modelo de execução padrão do PHP

PHP tradicionalmente segue um modelo de execução síncrona, especialmente quando usado com Apache em uma configuração típica de servidor web. Neste modelo, cada solicitação HTTP é tratada por um único processo PHP. As etapas envolvidas no processamento de uma solicitação incluem:

1. Apache recebe uma solicitação HTTP e a encaminha para PHP.
2. PHP executa o script do início ao fim em um único thread.
3. PHP retorna a saída ao Apache, que então envia a resposta de volta ao cliente.

Este modelo garante simplicidade e facilidade de compreensão, mas pode se tornar ineficiente para tarefas que exigem execução paralela ou manipulação de múltiplas tarefas simultaneamente.

Evolução da simultaneidade e paralelismo em PHP

À medida que as aplicações web se tornaram mais complexas, a necessidade de execução simultânea e paralela em PHP cresceu. Vamos explorar as técnicas que o PHP oferece para atingir esses paradigmas.

1. Código Síncrono

Código síncrono é a forma mais simples de execução onde as tarefas são executadas uma após a outra.

echo "Synchronous Code Example:\n";
function synchronousFunction() {
    for ($i = 0; $i 



Neste exemplo, cada iteração do loop é executada sequencialmente, com um atraso de um segundo entre as iterações. Essa abordagem é direta, mas ineficiente para tarefas vinculadas a E/S ou com uso intensivo de CPU que poderiam se beneficiar da execução paralela.


  
  
  2. Bifurcação de um processo


A bifurcação cria um novo processo (filho) que é executado simultaneamente com o processo original (pai). Isso é útil para paralelizar tarefas.


echo "\nForking Process Example:\n";
function forkProcess() {
    $pid = pcntl_fork();
    if ($pid == -1) {
        die('could not fork');
    } else if ($pid) {
        echo "Parent Process: PID $pid\n";
        pcntl_wait($status); // Protect against Zombie children
    } else {
        echo "Child Process: Hello from the child process!\n";
        exit(0);
    }
}
forkProcess();




Neste código, pcntl_fork() cria um processo filho. Os processos pai e filho são executados simultaneamente, permitindo a execução paralela de tarefas. O processo pai aguarda a conclusão do processo filho para evitar a criação de processos zumbis.


  
  
  3. Rosqueamento


Os recursos de threading do PHP estão disponíveis por meio de extensões como pthreads. Threads são mais leves que processos e compartilham o mesmo espaço de memória, tornando-os adequados para tarefas que exigem dados compartilhados.


if (!class_exists('Thread')) {
    die("Threads are not supported in this PHP build\n");
}

echo "\nThreading Example:\n";
class MyThread extends Thread {
    public function run() {
        for ($i = 0; $i start();
$thread->join();




Este exemplo define uma classe MyThread que estende Thread. O método run é executado em um novo thread, rodando simultaneamente com o thread principal. Essa abordagem é útil para operações vinculadas a E/S, nas quais os threads podem lidar com a espera por recursos.


  
  
  4. Geradores


Os geradores fornecem uma maneira de implementar co-rotinas simples, permitindo que as funções produzam resultados iterativamente sem bloquear todo o programa.


echo "\nGenerators Example:\n";
function simpleGenerator() {
    yield 'First';
    yield 'Second';
    yield 'Third';
}

$gen = simpleGenerator();
foreach ($gen as $value) {
    echo "Generator Yielded: $value\n";
}




Os geradores usam a palavra-chave yield para produzir valores um de cada vez, permitindo que a função seja pausada e retomada, facilitando uma forma de multitarefa cooperativa.

PHP percorreu um longo caminho desde suas raízes síncronas para suportar várias formas de simultaneidade e paralelismo. Embora o código síncrono permaneça simples e eficaz para muitos casos de uso, técnicas como bifurcação de processos, threading e uso de geradores abrem novas possibilidades para lidar com tarefas complexas e paralelizáveis ​​de forma eficiente.