PHP asincrónico

La asincronía es la capacidad de un sistema de software para no bloquear el hilo principal de ejecución.
Una operación asincrónica es una operación que no bloquea el flujo de ejecución de un programa hasta que se completa.

Operaciones de bloqueo

public function update(User $user)
{
    try {
        $sql = 'UPDATE users SET ...';
        return $this->connection->execute($sql, $user->data());
    } catch (\PDOException $error) {
        log($error->getMessage());
    }

    return 0;
}

• Sistema de archivos : fwrite, file_get_contents.
• Bases de datos : PDOConnection, RedisClient. Casi todas las extensiones para conectar una base de datos funcionan en modo de bloqueo de forma predeterminada.
• Procesos : exec, system, proc_open. Estas son operaciones de bloqueo, ya que todo el trabajo con procesos se construye a través de llamadas al sistema.
• Trabajar con stdin / stdout : readline, echo, print.

Cliente SQL asincrónico

public function execAsync(string $query, array $params = [])
{
    $socket = stream_socket_client('127.0.0.1:3306', ...);

    stream_set_blocking($socket, false);

    $data = $this->packBinarySQL($query, $params);
    
    socket_write($socket, $data, strlen($data));
}

Promesa

Promise es un objeto contenedor sobre el resultado de una operación asincrónica. Además, el resultado de la operación aún es desconocido para nosotros.

Cómo funciona la promesa

interface Promise
{
    const
        STATUS_PENDING = 0,
        STATUS_RESOLVED = 1,
        STATUS_REJECTED = 2
    ;

    public function onResolve(callable $callback);
    public function onReject(callable $callback);
    public function resolve($data);
    public function reject(\Throwable $error);
}

Cliente SQL asincrónico

public function execAsync(string $query, array $params = [])
{
    $deferred = new Deferred;

    $socket = stream_socket_client('127.0.0.1:3306', ...);
    stream_set_blocking($socket, false);

    $data = $this->packBinarySQL($query, $params);
    socket_write($socket, $data, strlen($data));

    return $deferred->promise();
}

• configure la devolución de llamada y obtenga los affected rowsque nos devuelven PDOConnection;
• manejar el error, agregar al registro;
• Vuelva a intentar la consulta si el servidor SQL responde con un error.

$promise = $this->execAsync($sql, $user->data());

$promise->onResolve(function (int $rows) {
    echo "Affected rows: {$rows}";
});

$promise->onReject(function (\Throwable $error) {
    log($error->getMessage());
});

Bucle de eventos

• El cliente le dice a Event Loop que está interesado en algún tipo de socket.
• Event Loop sondea el sistema operativo a través de una llamada al sistema stream_select: está listo el socket, están escritos todos los datos, son los datos que provienen del otro lado.
• Si el sistema operativo informa que el socket no está listo, bloqueado, entonces Event Loop repite el ciclo.
• Cuando el sistema operativo notifica que el socket está listo, Event Loop devuelve el control al cliente y habilita ( resolveo reject) Promise.

public static function run()
{
    while (true) {
        stream_select($readSockets, $writeSockets, null, 0);
        
        foreach ($readSockets as $i => $socket) {
            call_user_func(self::readCallbacks[$i], $socket);
        }

        // Do same for write sockets
    }
}

public function execAsync(string $query, array $params = [])
{
    $deferred = new Deferred;
    ...
    Loop::onReadable($socket, function ($socket) use ($deferred) {
        $deferred->resolve(socket_read($socket));
    });

    return $deferred->promise();
}

• JavaScript setTimeout setInterval — . N . Event Loop .
• Event Loop . process control, .

Event Loop

ReactPHP

$connection = (new ConnectionFactory)->createLazyConnection();

$promise = $connection->query('UPDATE users SET ...');
$promise->then(
    function (QueryResult $command) {
        echo count($command->resultRows) . ' row(s) in set.';
    },
    function (Exception $error) {
        echo 'Error: ' . $error->getMessage();
    });

    function (QueryResult $command) {
        echo count($command->resultRows) . ' row(s) in set.';
    },

    function (Exception $error) {
        echo 'Error: ' . $error->getMessage();
    });

$promise
    ->then(function ($data) {
        return new Promise(...);
    })
    ->then(function ($data) {
        ...
    }, function ($error) {
        log($error);
    })
    ...

Amphp

$pool = Mysql\pool("host=127.0.0.1 port=3306 db=test");

try {
    $result = yield $pool->query("UPDATE users SET ...");

    echo $result->affectedRows . ' row(s) in set.';
} catch (\Throwable $error) {
    echo 'Error: ' . $error->getMessage();
}

Generadores

function generator($counter = 1)
{
    yield $counter++;

    echo "A";

    yield $counter;

    echo "B";

    yield ++$counter;
}

$generator = generator(1);

foreach ($generator as $value) {
    echo $value;
}

while ($generator->valid()) {
    echo $generator->current();

    $generator->next();
}

Corutinas

function printer() {  
    while (true) {     
        echo yield;       
    }                             
}                                

$print = printer();
$print->send('Hello');
$print->send(' PHPRussia');
$print->send(' 2019');
$print->send('!');

function printer() {
    try {
        echo yield;
    } catch (\Throwable $e) {
        echo $e->getMessage();
    }
}

printer()->throw(new \Exception('Ooops...'));

Generadores y promesa

class Generator
{
    public function send($data);
    public function throw(\Throwable $error);
}

class Promise
{
    public function resolve($data);
    public function reject(\Throwable $error);
}

function recoil(\Generator $generator)
{
    $promise = $generator->current();

    $promise->onResolve(function($data) use ($generator) {
        $generator->send($data);
        recoil($generator);
    };

    $promise->onReject(function ($error) use ($generator) {
        $generator->throw($error);
        recoil($generator);
    });
}

    $promise->onResolve(function($data) use ($generator) {
        $generator->send($data);
        recoil($generator);
    };

Multitarea cooperativa

Procesamiento de solicitudes en PHP

• Manejo simple de errores . Si algo salió mal y una de las solicitudes cayó, no necesitamos hacer nada; la próxima vendrá, y esto no afectará su trabajo.
• No pensamos en la memoria . No necesitamos limpiar ni monitorear la memoria. En la siguiente solicitud, se borrará toda la memoria.

• Limite el número de procesos . Si tenemos 50 subprocesos FPM en el servidor, tan pronto como llegue la solicitud 51, esperará hasta que uno de los subprocesos se libere.
• Costos por cambio de contexto . El sistema operativo cambia las solicitudes entre transmisiones FPM. Esta operación a nivel de procesador se llama Cambio de contexto. Es costoso y ejecuta una gran cantidad de medidas. Es necesario guardar todos los registros, la pila de llamadas, todo lo que está en el procesador, luego cambiar a otro proceso, cargar sus registros y su pila de llamadas, realizar algo allí nuevamente, cambiar de nuevo, guardar de nuevo ... Durante mucho tiempo.

Servidor HTTP asincrónico

Loop::run(function () {
    $app = new Application();
    $app->bootstrap();

    $sockets = [Socket\listen('0.0.0.0:80')];

    $server = new Server($sockets, new CallableRequestHandler(
        function (Request $request) use ($app) {
            $response = yield $app->dispatch($request);

            return new Response(Status::OK, [], $response);
        })
    );

    yield $server->start();
});

Problemas

class UserRepository
{
    public function find(int $id): \Generator
    {
        $data = yield $this->db->query('SELECT ...', $id);

        return User::fill($data);
    }
}

PHP 8

class UserRepository
{
    public function find(int $id): Promise<User>
    {
        $data = await $this->db->query('SELECT ...', $id);

        return User::fill($data);
    }
}

class UserRepository
{
    public function find(int $id): Promise<User>
    {
        $data = yield $this->db->query('SELECT ...', $id);

        return User::fill($data);
    }
}

¿Por qué todo esto?

Por velocidad y rendimiento.

El 13 de mayo de 2020, nos reuniremos por segunda vez en PHP Rusia para discutir el lenguaje, las bibliotecas y los marcos, las formas de aumentar la productividad y las dificultades de las soluciones publicitarias. Hemos aceptado los primeros 4 informes , pero Call for Papers aún está por llegar. Solicite si desea compartir su experiencia con la comunidad.