Méthode d'implémentation asynchrone non bloquante PHP

Afin d'éviter que PHP ne se bloque lors du traitement de tâches à long terme sur le backend et de répondre rapidement aux demandes de pages, les mesures suivantes peuvent être prises :

Utilisez fastcgi_finish_request()

Si PHP et le serveur Web utilisent PHP-FPM (FastCGI Process Manager), la session peut être terminée immédiatement via la fonction fastcgi_finish_request(), et le thread PHP peut continuer à s'exécuter en arrière-plan.

echo "program start...";
file_put_contents('log.txt','start-time:'.date('Y-m-d H:i:s'), FILE_APPEND);
fastcgi_finish_request();
sleep(1);
echo 'debug...';
file_put_contents('log.txt', 'start-proceed:'.date('Y-m-d H:i:s'), FILE_APPEND);
sleep(10);
file_put_contents('log.txt', 'end-time:'.date('Y-m-d H:i:s'), FILE_APPEND);

Comme le montrent les résultats de sortie, une fois la page imprimée, le démarrage du programme..., la session revient après avoir sorti la première ligne dans log.txt, donc le débogage suivant... ne sera pas parcouru. Il est affiché sur le serveur et le fichier log.txt peut recevoir entièrement les trois temps d'achèvement.

2. Utilisez fsockopen()

Utilisez fsockopen() pour ouvrir une connexion réseau ou une connexion socket Unix, puis utilisez stream_set_blocking() pour demander en non- mode de blocage :

$fp = fsockopen("www.example.com", 80, $errno, $errstr, 30);
if (!$fp) {
    die('error fsockopen');
}
// 转换到非阻塞模式
stream_set_blocking($fp, 0);
$http = "GET /save.php  / HTTP/1.1\r\n";
$http .= "Host: www.example.com\r\n";
$http .= "Connection: Close\r\n\r\n";
fwrite($fp, $http);
fclose($fp);

3. Utilisez cURL

Utilisez la fonction curl_multi_* dans cURL pour envoyer des requêtes asynchrones

$mh = curl_multi_init();
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "http://localhost/");
curl_multi_add_handle($mh, $ch);
curl_multi_exec($mh, $active);
curl_close($ch);
curl_multi_remove_handle($mh, $ch);
curl_multi_close($mh);
echo "End\n";

4. Utilisez l'extension Gearman/Swoole

Gearman est un framework de traitement asynchrone distribué avec une extension PHP qui peut gérer de gros lots de tâches asynchrones.

Swoole a été très populaire récemment. Il propose de nombreuses méthodes asynchrones et est facile à utiliser.

5. Utilisez des caches et des files d'attente

Utilisez Redis et d'autres caches et files d'attente pour écrire des données dans le cache, et utilisez des tâches planifiées en arrière-plan pour réaliser un traitement asynchrone des données.

Cette méthode devrait être très courante dans les architectures courantes à fort trafic

6. Appeler les commandes du système

Dans les cas extrêmes, vous pouvez appeler le système. La commande peut transmettre des données aux tâches en arrière-plan pour exécution, mais je pense personnellement que ce n'est pas très efficace.

$cmd = 'nohup php ./processd.php $someVar >/dev/null  &';
`$cmd`

7. Utilisez pcntl_fork()

pour installer l'extension pcntl et utilisez pcntl_fork() pour générer un processus enfant pour exécuter des tâches de manière asynchrone. Je pense que c'est le plus pratique, mais des processus zombies sont également susceptibles d'apparaître.

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!