Nos últimos artigos eu tenho escrito sobre programação assíncrona em PHP com ReactPHP e Swoole. O Swoole tem seu mecanismo interno próprio de corrotinas, mas o que muita gente não sabe é que podemos trabalhar com corrotinas usando PHP puro, através de generators.
Curso PHP - Fundamentos
Conhecer o cursoEu achei que fosse interessante escrever sobre isso até mesmo como uma forma de apresentar às pessoas o conceito de generators e também como uma forma de instigá-las a buscar mais sobre o tema.
A ideia desse artigo é construir um simples (muito simples) scheduler de corrotinas bem primitivo e didático. Em outros artigos eu escrevi de forma mais abrangente sobre generators, código síncrono, assíncrono, corrotinas etc, conceitos esses que serão importantes você ter para entender o funcionamento do nosso exemplo aqui. Por esse motivo, eu recomendo que você leia esses artigos:
-
Concorrência, Paralelismo, Processos, Threads, programação síncrona e assíncrona: Concorrência, paralelismo, processos, threads, programação síncrona e assíncrona, são assuntos que permeiam o dia a dia dos desenvolvedores. A ideia desse artigo é descomplicar um pouco o que esses conceitos significam e como eles se relacionam.
-
Introdução à programação assíncrona em PHP usando o ReactPHP: esse artigo vai introduzir todo o essencial sobre programação síncrona e assíncrona;
-
Introdução ao Swoole, framework PHP assíncrono baseado em corrotinas: esse artigo também vai falar sobre desenvolvimento assíncrono e também introduzirá alguns conceitos importantes como o de corrotina.
Opcionalmente, se você tiver interesse, também recomendo a leitura deste artigo:
- Trabalhando com corrotinas, canais e explorando um pouco mais o scheduler de corrotinas do Swoole: artigo que vai apresentar muita teoria importante sobre corrotinas e scheduler de corrotinas.
Esse artigo que você está lendo é, de certa forma, uma ramificação deste:
Portanto, o artigo Generators no PHP é realmente uma leitura necessária para entender os códigos que desenvolveremos aqui.
Curso PHP - Orientação a Objetos - Parte 1
Conhecer o cursoGênesis
Sabemos que generators são como se fossem funções que podem ser interrompidas e resumidas a qualquer momento. Também sabemos que assincronismo é sobre fluxo de execução. Captando essas duas ideias centrais, podemos chegar na seguinte conclusão lógica: se um generator pode ser interrompido para que outro seja executado, eu posso usar isso para manipular o fluxo de uma execução e então atingir uma modelagem de código assíncrono.
Primeiro vamos ver um exemplo de código síncrono:
<?php
declare(strict_types=1);
$booksTask = static function () {
for ($i = 1; $i <= 4; ++$i) {
echo "Book $i\n";
}
};
$moviesTask = static function () {
for ($i = 1; $i <= 8; ++$i) {
echo "Movie $i\n";
}
};
$booksTask();
$moviesTask();
O resultado dessa execução:
Book 1
Book 2
Book 3
Book 4
Movie 1
Movie 2
Movie 3
Movie 4
Movie 5
Movie 6
Movie 7
Movie 8
A execução é síncrona, linear e previsível. Temos duas tarefas, mas a segunda ($moviesTask) só terá oportunidade de desempenhar seu trabalho depois que a primeira ($booksTask) terminar tudo o que tem para ser feito.
Podemos transformar esse exemplo em um código de modelo assíncrono usando generators e trabalhando com a ideia de que cada task é uma corrotina. Para isso, dois princípios são importantíssimos:
- Uma Task (tarefa) será apenas um decorator de um generator;
- Um Scheduler cuidará da fila de tarefas e da execução delas;
O exemplo pode ser encontrado no GitHub: https://github.com/KennedyTedesco/coroutines-php
Uma tarefa será representada pela classe Task:
<?php
declare(strict_types=1);
namespace Coral;
use Generator;
final class Task
{
private $coroutine;
protected $firstYield = true;
public function __construct(Generator $coroutine)
{
$this->coroutine = $coroutine;
}
public function run(): void
{
if ($this->firstYield) {
$this->firstYield = false;
$this->coroutine->current();
} else {
$this->coroutine->next();
}
}
public function finished(): bool
{
return ! $this->coroutine->valid();
}
}
A tarefa é apenas um decorator de um generator.
E o Scheduler será representado pela classe de seu próprio nome:
<?php
declare(strict_types=1);
namespace Coral;
use SplQueue;
final class Scheduler
{
private $tasks;
public function __construct()
{
$this->tasks = new SplQueue();
}
public function schedule(Task $task): void
{
$this->tasks->enqueue($task);
}
public function handle(): void
{
while (! $this->tasks->isEmpty()) {
/** @var Task $task */
$task = $this->tasks->dequeue();
$task->run();
if (! $task->finished()) {
$this->schedule($task);
}
}
}
}
O Scheduler mantém uma fila de tarefas a serem executadas e possui um método público schedule() para adicionar tarefas nessa fila. O método handle() itera nas tarefas executando-as. Antes de entrarmos em mais detalhes, ao executar o exemplo:
<?php
declare(strict_types=1);
require 'vendor/autoload.php';
use Coral\Task;
use Coral\Scheduler;
$scheduler = new Scheduler();
$booksTask = static function () {
for ($i = 1; $i <= 4; ++$i) {
echo "Book $i\n";
yield;
}
};
$moviesTask = static function () {
for ($i = 1; $i <= 8; ++$i) {
echo "Movie $i\n";
yield;
}
};
$scheduler->schedule(new Task($booksTask()));
$scheduler->schedule(new Task($moviesTask()));
$scheduler->handle();
Nota: As duas tarefas retornam um generator, que depois é passado para o construtor de Task.
Temos o seguinte resultado:
Book 1
Movie 1
Book 2
Movie 2
Book 3
Movie 3
Book 4
Movie 4
Movie 5
Movie 6
Movie 7
Movie 8
Diferentemente do exemplo síncrono mostrado anteriormente, neste temos a alternância da execução das tarefas, no sentido de que são colaborativas, uma abre espaço para que a outra também tenha oportunidade de ser executada. Isso acontece pois o Scheduler executa a tarefa, o valor corrente dela é impresso, nisso ela volta novamente para a fila do Scheduler para ser executada novamente em outro momento. As tarefas sempre voltam para a fila enquanto ainda tiverem valores a serem processados:
$task->run();
if (! $task->finished()) {
$this->schedule($task);
}
Essa é uma estratégia para mantê-las em sua essência colaborativas, ou seja, a tarefa abre mão do seu tempo de execução para que outra tarefa também tenha oportunidade.
Considerações finais
Este foi um simples exemplo de como podemos ter uma operação assíncrona utilizando generators. E aqui nem estamos nos referindo a multiplexing de I/O, mas poderíamos usar esse mesmo conceito de generators e implementar I/O não bloqueante (assíncrono) usando algum padrão como o Reactor, usado pelo ReactPHP ou algo mais “simples” usando diretamente a função stream_select(). Inclusive, O Nikita Popov (desenvolvedor do core do PHP) escreveu exatamente sobre isso no artigo Cooperative multitasking using coroutines (in PHP!), que por sinal, é a principal referência desse artigo aqui. Recomendo essa leitura pois ele também fez com que o generator se comunicasse com outros generators e com o Scheduler (que é a realmente essência de uma corrotina), numa espécie de canal de comunicação, o que torna as coisas ainda mais poderosas. O framework assíncrono Amp faz um uso bem intensivo de generators, também vale a pena testá-lo.
Ah, não poderia deixar de pontuar novamente: se você tem interesse por programação assíncrona com PHP, vale a pena a leitura desses artigos:
- Introdução à programação assíncrona em PHP usando o ReactPHP: esse artigo vai introduzir todo o essencial sobre programação síncrona e assíncrona;
- Introdução ao Swoole, framework PHP assíncrono baseado em corrotinas: esse artigo também vai falar sobre desenvolvimento assíncrono e também introduzirá alguns conceitos importantes como o de corrotina.
Até a próxima!
