Threads no PHP com pthreads

Introdução

Thread é um importante recurso de algumas linguagens de programação, que provê melhoria de performance através da execução de blocos de instruções em paralelo. Por outro lado, ela também exige uma forma própria de pensar na solução dos problemas. Neste artigo, veremos rapidamente o que são threads e um tutorial de como e onde elas podem poderão ser usadas com PHP.

---

O que são threads?

Antes de responder a esta pergunta, é preciso dizer que existem dois tipos de threads: Kernel Level Thread (KLT) e User Level Thread (ULT). Neste artigo, vamos nos concentrar apenas nas threads do tipo ULT, que são as suportadas pelo PHP.

Uma ULT é um conjunto de instruções que pode ser executado em paralelo com outras instruções do mesmo programa. Desta forma, quando temos um dispositivo (computador) com vários processadores ou um processador com vários núcleos (multi-cores), é possível colocar duas (ou mais) threads do mesmo processo rodando em paralelo, cada uma em um processador ou núcleo próprio. O resultado disso é uma potencial melhoria na performance do processo. Ou seja, ao invés de executar instrução por instrução sequencialmente, você consegue executar alguns blocos de instruções em paralelo e, em determinados pontos do código, exigir uma sincronização para garantir que os "resultados" ou processamentos executados pelas tarefas paralelas tenham sido concluídas.

Uma característica importante a se destacar é que as threads compartilham a mesma região de memória do processo que a iniciou. Portanto, várias threads podem trabalhar sobre o mesmo dado da memória. Por fazerem parte de um único processo, utilizar threads normalmente tem melhor performance do que executar vários processos iguais em paralelo. Por outro lado, threads precisam ter algum tipo de controle sobre o acesso ao mesmo dado, já que pode existir acesso concorrente.

---

Como usar Threads no PHP?

Instalação do pthreads

No PHP, assim como outras linguagens de programação, o suporte a threads é feito através de um módulo (extensão). No caso do PHP, o módulo pthreads é o módulo responsável pelo suporte a threads. Ele é um módulo Pecl, portanto possui boa performance.

Até o momento que este artigo foi escrito, este módulo está em fase Beta, ou seja, ainda não é a versão final estável para uso. Porém, é útil conhecer seus recursos e experimentá-los para tirar proveito dele quando ele estiver mais estável. Certamente é um módulo muito promissor e que, até o momento, tem tido resultados satisfatórios.

Para instalar o módulo pthreads, é necessário que o PHP esteja compilado com suporte a ZTS e isso é feito incluindo a opção --enable-maintainer-zts (ou --enable-zts para Windows) durante a compilação do PHP.

Depois, basta instalar o módulo Pecl pthreads normalmente. Caso tenha dúvidas sobre o que são módulos Pecl e como são instalados, leia o artigo Instalação de módulos Pear e Pecl.

Utilização do pthreads

O módulo pthreads oferece três classes principais para utilização: Thread, Worker e Stackable. Por enquanto, veremos apenas a classe Thread, que já possui muita coisa envolvida. Num próximo artigo falaremos da Worker e Stackable, que são estruturas usadas para casos mais específicos.

A classe Thread permite a criação de uma thread simples. Ela é uma classe abstrata, portanto precisa ser herdada por uma classe filha para ser usada. Ela oferece vários métodos finais (que não podem ser sobrescritos nas classes filhas) e um método abstrato (que obrigatoriamente precisa ser implementado nas classes filhas concretas). O método abstrato chama-se "run" e ele deve agrupar o conjunto de instruções da thread que poderá ser executado em paralelo com outras instruções do programa.

Veja um exemplo simples de 10 threads executadas em paralelo e cada uma terminando em um tempo diferente:

<?php
// Classe que aguarda um tempo aleatorio e depois imprime algo na tela
class AguardaRand extends Thread {

    // ID da thread (usado para identificar a ordem que as threads terminaram)
    protected $id;

    // Construtor que apenas atribui um ID para identificar a thread
    public function __construct($id) { 
        $this->id = $id;
    }

    // Metodo principal da thread, que sera acionado quando chamarmos "start"
    public function run() {
        // Sortear um numero entre 1 e 4
        $tempo_rand = mt_rand(1, 4);

        // Aguardar o tempo sorteado
        sleep($tempo_rand);

        // Imprimir quem e' a thread e quanto tempo ela aguardou
        printf(
            "Sou a thread %d e aguardei %d segundos\n",
            $this->id,
            $tempo_rand
        );
    }
}

/// Execucao do codigo

// Criar um vetor com 10 threads do mesmo tipo
$vetor = array();
for ($id = 0; $id < 10; $id++) {
    $vetor[] = new AguardaRand($id);
}

// Iniciar a execucao das threads
foreach ($vetor as $thread) {
    $thread->start();
}

// Encerrar o script
exit(0);

Observe que chamamos o método start, ao invés de chamar o método run. O método start serve justamente para iniciar a execução da thread, mas continuar a execução das instruções do script corrente. O método run será acionado automaticamente pelo método start (em uma thread de processo diferente), logo você não deve chamar o método run diretamente.

Portanto, o que o script vai fazer é iniciar todas as threads quase que ao mesmo tempo e executá-las quase em paralelo. Digo "quase" porque não tenho 10 processadores, então a execução de cada thread vai se alternar nos processadores disponíveis, conforme a disponibilidade de uso gerenciado pelo sistema operacional, causando a impressão de que executaram em paralelo. Cada thread vai sortear um tempo aleatório para aguardar e depois vai imprimir uma mensagem. O resultado impresso é aleatório, mas o importante destacar aqui é que todas que sortearam o valor "1" vão se encerrar (aproximadamente) após 1 segundo do início da execução das threads; as que sortearam o valor "2" vão se encerrar após 2 segundos do início da execução das threads; e assim sucessivamente. Um exemplo de resultado impresso é este:

Sou a thread 5 e aguardei 1 segundos
Sou a thread 8 e aguardei 1 segundos
Sou a thread 2 e aguardei 2 segundos
Sou a thread 0 e aguardei 3 segundos
Sou a thread 9 e aguardei 3 segundos
Sou a thread 1 e aguardei 4 segundos
Sou a thread 3 e aguardei 4 segundos
Sou a thread 4 e aguardei 4 segundos
Sou a thread 6 e aguardei 4 segundos
Sou a thread 7 e aguardei 4 segundos

Note que, embora as threads tenham sido iniciadas em sequência (1, 2, 3, ...), as threads 5 e 8 foram as primeiras a terminar a execução, pois elas sortearam o valor "1" (aguardaram só um segundo), que era o menor tempo possível que poderia ser sorteado.

Observação: no exemplo anterior, utilizamos 10 instâncias de threads do mesmo tipo. Porém, em situações reais, pode ser que você queira executar threads de tipos diferentes em paralelo. Rodar threads do mesmo tipo é útil quando queremos, por exemplo, realizar operações idênticas sobre elementos de um vetor muito grande. Neste caso, cada thread pode realizar a mesma operação, mas em fatias específicas do vetor.

Com os métodos apresentados (run e start) já conseguiremos fazer o básico, que é colocar instruções para rodar em paralelo. Mas existem situações mais complexas onde queremos executar instruções em paralelo, mas depois precisaremos dos resultados gerados por estas instruções para fazer alguma coisa com eles. Neste caso, precisamos usar o método join no ponto em que queremos garantir que uma determinada thread já tenha terminado.

Veja um exemplo de como usaríamos o método join:

...

// Criar uma thread para calcular alguma coisa em "segundo plano"
$minhaThread = new MinhaThread();

// Iniciar a execucao da thread e seguir com as instrucoes do script
$minhaThread->start();

// Agora fazemos alguma outra coisa enquanto a thread esta sendo executada
fazerAlgumaCoisa();

// Agora queremos usar o resultado do processamento da thread,
// entao precisamos garantir que ela tenha terminado
$minhaThread->join();

// Aqui temos a garantia de que a thread terminou, entao podemos
// pegar o resultado que ela calculou
$resultadoThread = $minhaThread->obterResultado();

// Agora podemos usar o $resultadoThread com seguranca
...

Neste exemplo, imaginemos que a classe MinhaThread calcula alguma coisa e armazena em algum atributo da classe. Depois, o método público obterResultado é responsável por obter o valor do atributo, que guarda o resultado calculado pelo método run.

Se voltarmos ao primeiro exemplo, veremos que não usei o método join. Apenas iniciamos as threads e chamamos o comando exit. Porém, quando o script termina (final do arquivo ou chamada ao comando exit), ele na verdade aguarda o encerramento de todas as threads que foram iniciadas. Se você deseja enviar o pacote HTTP de resposta para o cliente e não quer aguardar as threads terminarem, uma solução é chamar a função fastcgi_finish_request. Só que, como o nome já sugere, esta função só funcionará para instalações do PHP que utilizam FastCGI.

Com o que foi apresentado, dá pra imaginar que a estratégia e modelagem da solução de problemas usando threads é diferente. É preciso avaliar as etapas necessárias para solução do problema e então verificar quais delas podem ser executadas em paralelo. Isso normalmente é feito avaliando se uma etapa depende do resultado de outra. Por outro lado, também existem as etapas que podem ser quebradas em partes menores e as threads realizarem operações similares, mas em fatias de dados específicas, como citado anteriormente.

---

Conclusão

Eu pretendia escrever um pouco mais sobre Threads, especialmente sobre o acesso concorrente de threads aos dados na memória, mas como o artigo já está começando a ficar muito grande, vou deixar para outra oportunidade. Em todo caso, com o que foi mostrado já é possível fazer alguns experimentos interessantes.