Quelles sont les méthodes d'implémentation des E/S non bloquantes en PHP7.0 ?

PHP7.0 est un langage de programmation populaire largement utilisé dans le développement Web et le développement côté serveur. L'une des mises à jour importantes est l'introduction d'E/S non bloquantes. Les E/S non bloquantes sont une technique de programmation asynchrone qui peut gérer plusieurs opérations d'E/S simultanément sans bloquer le thread actuel. Cette technique améliore considérablement les performances et la réactivité de la concurrence. Cet article présentera l'implémentation des E/S non bloquantes dans PHP7.0.

1. Stream Select

Stream Select est l'une des implémentations d'E/S non bloquantes les plus simples de PHP7.0. Cette méthode utilise l'appel système select pour vérifier si tous les flux de fichiers (les flux font référence aux descripteurs de fichiers ouverts, aux sockets, etc.) ont des données lisibles et, si c'est le cas, lisez les données. Ce processus est non bloquant et ne bloque donc pas le processus en cours.

Le code d'utilisation de Stream Select est le suivant :

$read = array($fp);
$write = array();
$except = array();
if (false === ($num_changed_streams = stream_select($read, $write, $except, 0))) {
    die('Error Occured');
} elseif ($num_changed_streams > 0) {
    //有数据可读
    $data = fread($fp, $buffer_size);
} else {
    //无数据可读
}

Le code ci-dessus utilise d'abord la fonction stream_select pour vérifier s'il y a des données lisibles, et si c'est le cas, lit les données . Ce processus de vérification est non bloquant et ne bloque donc pas le processus en cours.

2. Event Loop

Event Loop est une autre implémentation d'E/S non bloquante couramment utilisée dans PHP7.0. La boucle d'événements implémente des opérations d'E/S non bloquantes en enregistrant des fonctions de rappel d'événements, qui sont appelées lorsque des événements se produisent. Dans la boucle d'événements, l'application gère les opérations d'E/S en ajoutant des événements et en démarrant la boucle d'événements. Par exemple, dans le développement Web, vous pouvez utiliser Event Loop pour gérer les requêtes HTTP.

Ce qui suit est un exemple d'utilisation d'Event Loop pour gérer les requêtes HTTP :

$loop = ReactEventLoopFactory::create();
$client = new ReactHttpClientClient($loop);

$request = $client->request('GET', 'http://www.example.com/');
$request->on('response', function ($response) {
    $response->on('data', function ($chunk) {
        echo $chunk;
    });
});
$request->end();

$loop->run();

Dans l'exemple ci-dessus, un objet Event Loop $loop basé sur ReactPHP est d'abord créé, et puis un client HTTP $client et lance une requête GET. Dans la fonction de rappel de la réponse à la demande, utilisez echo pour afficher les données reçues.

3. Coroutine

Coroutine est une autre implémentation d'E/S non bloquante introduite dans PHP7.0. Coroutine profite des caractéristiques des coroutines pour suspendre la coroutine actuelle et exécuter d'autres coroutines lors du traitement des opérations d'E/S. Lorsque l'opération d'E/S est terminée, la coroutine peut reprendre son exécution et continuer à exécuter le code suivant. Ce processus est non bloquant.

Ce qui suit est un exemple d'utilisation de Coroutine pour gérer les opérations d'E/S :

$server = new SwooleServer("127.0.0.1", 9501, SWOOLE_PROCESS, SWOOLE_SOCK_TCP);

$server->on('Receive', function ($serv, $fd, $from_id, $data) {
    $result = "";
    $fp = stream_socket_client("tcp://127.0.0.1:80", $errno, $errstr, 30);
    fwrite($fp, $data);
    while (!feof($fp)) {
        $result .= fgets($fp, 1024);
    }
    fclose($fp);
    swoole_coroutine::sleep(0.1);
    $serv->send($fd, $result);
});

$server->start();

Dans le code ci-dessus, utilisez d'abord l'extension Swoole pour créer un objet serveur TCP $server . Dans la fonction de rappel qui reçoit les données client, utilisez la fonction stream_socket_client pour lancer une requête HTTP et utilisez une boucle while pour lire les données de réponse. Pendant le processus de lecture des données, utilisez swoole_coroutine::sleep(0.1) pour suspendre l'exécution de la coroutine actuelle et attendre que d'autres coroutines s'exécutent. Lorsque les données de réponse sont lues avec succès, les données sont renvoyées au client.

Conclusion

PHP7.0 introduit une variété de méthodes d'implémentation d'E/S non bloquantes, notamment Stream Select, Event Loop et Coroutine. Ces technologies permettent aux applications PHP de gérer plusieurs opérations d'E/S en même temps, améliorant ainsi les performances de concurrence et la vitesse de réponse. De nombreux frameworks et bibliothèques PHP, tels que ReactPHP et Swoole, ont intégré ces technologies d'E/S non bloquantes pour aider les développeurs à écrire des applications Web hautes performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!