Exécutez PHP Tâche Asynchrone

J'ai utilisé les files d'attente approche, et il fonctionne bien comme vous pouvez différer le traitement jusqu'à ce que votre charge de serveur est inactif, vous permettant de gérer votre charge de façon très efficace si vous pouvez partition off "à des tâches qui ne sont pas urgentes" facilement.

Roulement de votre propre n'est pas trop difficile, voici quelques autres options pour vérifier:

• GearMan - cette réponse a été écrit en 2009, et depuis GearMan semble une option populaire, voir les commentaires ci-dessous.
• ActiveMQ si vous voulez une véritable open source file d'attente de messages.
• ZeroMQ - c'est une super bibliothèque de socket qui permet d'écrire facilement distribué code sans avoir à trop se soucier de la prise de la programmation elle-même. Vous pouvez l'utiliser pour message queuing sur un seul hôte - vous serait tout simplement avoir votre webapp pousser quelque chose à une file d'attente d'un fonctionnement continu de la console d'application de la consommer à la prochaine occasion
• beanstalkd - seulement trouvé celui-ci lors de l'écriture de cette réponse, mais semble intéressant
• dropr est un PHP de message sur la file d'attente de projet, mais n'a pas été activement maintenu depuis Sep 2010
• php-mise en file d'attente est un récemment (2017), a maintenu wrapper autour d'une variété de systèmes de file d'attente
• Enfin, un blog sur l'utilisation de memcached pour message queuing

Un autre, peut-être plus simple consiste à utiliser ignore_user_abort - une fois que vous avez envoyé la page de l'utilisateur, vous pouvez faire votre traitement final sans crainte de cessation prématurée, même si ce ne sont l'effet de l'apparition de prolonger le chargement de la page à partir du point de vue utilisateur.

Une autre façon de fourche processus est via curl. Vous pouvez configurer vos tâches internes comme un service web. Par exemple:

• http://domain/tasks/t1
• http://domain/tasks/t2

Puis dans votre utilisateur a accédé scripts d'effectuer des appels vers le service:

$service->addTask('t1', $data); //post data to URL via curl

Votre service pouvez garder une trace de la file d'attente de tâches avec mysql ou ce que vous voulez, le point est: c'est tout enveloppé à l'intérieur du service et votre script est juste de consommer de l'Url. Cela vous permet de déplacer le service sur une autre machine/serveur si nécessaire (c'est à dire facilement évolutive).

Ajoutant http autorisation ou d'une coutume régime d'autorisation (comme Amazon web services) vous permet d'ouvrir vos tâches à être consommés par d'autres personnes, des services (si vous voulez) et vous pourriez aller plus loin et ajouter un service de surveillance sur le dessus pour garder une trace de la file d'attente et le statut de la tâche.

• http://domain/queue?task=t1
• http://domain/queue?task=t2
• http://domain/queue/t1/100931

Il prend un peu de travail, mais il y a beaucoup d'avantages.

Si c'était seulement une question de la fourniture d'une tâche coûteuse, dans le cas de php-fpm est pris en charge, pourquoi ne pas utiliser fastcgi_finish_request() fonction?

Cette fonction efface toutes les données de réponse du client et des finitions de la demande. Cela permet de tâches consommatrices de temps à être réalisée sans laisser la connexion ouverte.

Vous n'avez pas vraiment utiliser l'asynchronicité de cette façon:

1. Faire de votre code principal en premier.
2. Exécuter fastcgi_finish_request().
3. Faire tous les gros trucs.

Une fois de plus, php-fpm est nécessaire.

C'est la même méthode que j'ai été de les utiliser pour un couple d'années maintenant et je n'ai pas vu ou trouvé quelque chose de mieux. Comme les gens l'ont dit, PHP est mono-thread, donc il n'y a pas grand chose d'autre que vous pouvez faire.

J'ai effectivement ajouté un niveau supplémentaire à l'obtenir et stocker l'id de processus. Cela me permet de rediriger vers une autre page et demandez à l'utilisateur de s'asseoir sur cette page, à l'aide d'AJAX pour vérifier si le processus est terminé (id de processus n'existe plus). C'est utile pour les cas où la longueur du script serait la cause de la navigateur de délai d'attente, mais l'utilisateur doit attendre que le script pour terminer avant la prochaine étape. (Dans mon cas, c'était le traitement de gros fichiers ZIP avec CSV comme les fichiers d'ajouter jusqu'à 30 000 enregistrements de la base de données après que l'utilisateur doit confirmer certaines informations.)

J'ai également utilisé un processus similaire pour la génération de rapports. Je ne suis pas sûr que je serais utilisation "traitement de fond" pour quelque chose comme un e-mail, sauf si il y a un réel problème avec la lenteur de la SMTP. Au lieu de cela je peut utiliser un tableau comme une file d'attente et ensuite avoir un processus qui s'exécute toutes les minutes pour envoyer les e-mails dans la file d'attente. Vous devez être warry de l'envoi d'e-mails deux fois ou autres problèmes similaires. Je le considère comme un analogue des files d'attente des processus pour d'autres tâches en tant que bien.

C'est une bonne idée d'utiliser cURL comme suggéré par rojoca.

Ici est un exemple. Vous pouvez surveiller text.txt alors que le script est en cours d'exécution en arrière-plan:

<?php
function doCurl($begin)
{
echo "Do curl<br />\n";
$url = 'http://'.$_SERVER['SERVER_NAME'].$_SERVER['REQUEST_URI'];
$url = preg_replace('/\?.*/', '', $url);
$url .= '?begin='.$begin;
echo 'URL: '.$url.'<br>';
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
echo 'Result: '.$result.'<br>';
curl_close($ch);
}
if (empty($_GET['begin'])) {
doCurl(1);
}
else {
while (ob_get_level())
ob_end_clean();
header('Connection: close');
ignore_user_abort();
ob_start();
echo 'Connection Closed';
$size = ob_get_length();
header("Content-Length: $size");
ob_end_flush();
flush();
$begin = $_GET['begin'];
$fp = fopen("text.txt", "w");
fprintf($fp, "begin: %d\n", $begin);
for ($i = 0; $i < 15; $i++) {
sleep(1);
fprintf($fp, "i: %d\n", $i);
}
fclose($fp);
if ($begin < 10)
doCurl($begin + 1);
}
?>

Si vous définissez la Longueur du Contenu d'en-tête HTTP dans votre "Merci De votre Inscription", le navigateur doit fermer la connexion après le nombre spécifié d'octets reçus. Cela laisse le de côté de serveur de processus en cours d'exécution (en supposant que ignore_user_abort est) de sorte qu'il peut terminer le travail sans faire l'utilisateur final d'attente.

Bien sûr, vous aurez besoin de calculer la taille de votre contenu de la réponse avant de rendre les en-têtes, mais c'est assez facile pour de courtes réponses (écrire la sortie d'une chaîne de caractères, appel strlen(), l'appel de l'en-tête(), le rendu de la chaîne).

Cette approche a l'avantage de pas vous forçant à gérer un "front end" file d'attente, et bien que vous devrez peut-être faire un peu de travail sur le back-end pour éviter de course HTTP enfant processus de marcher les uns sur les autres, c'est quelque chose que vous besoin de faire déjà, de toute façon.

je pense que vous devriez essayer cette technique, il aidera à appeler autant de pages que vous le souhaitez toutes les pages s'exécuter à la fois de manière indépendante, sans attente pour chaque page de réponse asynchrone.

cornjobpage.php //la page d'accueil

    <?php
post_async("http://localhost/projectname/testpage.php", "Keywordname=testValue");
//post_async("http://localhost/projectname/testpage.php", "Keywordname=testValue2");
//post_async("http://localhost/projectname/otherpage.php", "Keywordname=anyValue");
//call as many as pages you like all pages will run at once independently without waiting for each page response as asynchronous.
?>
<?php
/*
* Executes a PHP page asynchronously so the current page does not have to wait for it to     finish running.
*  
*/
function post_async($url,$params)
{
$post_string = $params;
$parts=parse_url($url);
$fp = fsockopen($parts['host'],
isset($parts['port'])?$parts['port']:80,
$errno, $errstr, 30);
$out = "GET ".$parts['path']."?$post_string"." HTTP/1.1\r\n";//you can use POST instead of GET if you like
$out.= "Host: ".$parts['host']."\r\n";
$out.= "Content-Type: application/x-www-form-urlencoded\r\n";
$out.= "Content-Length: ".strlen($post_string)."\r\n";
$out.= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
fclose($fp);
}
?>

testpage.php

    <?
echo $_REQUEST["Keywordname"];//case1 Output > testValue
?>

PS:si vous voulez envoyer des paramètres d'url comme boucle puis suivez cette réponse :https://stackoverflow.com/a/41225209/6295712

PHP est un single-threaded langue, donc il n'y a pas de manière officielle pour démarrer un processus asynchrone avec d'autres que l'aide exec ou popen. Il y a un post de blog à ce sujet ici. Votre idée pour une file d'attente dans le serveur MySQL est une bonne idée aussi.

Votre condition spécifique est ici pour envoyer un email à l'utilisateur. Je suis curieux de savoir pourquoi vous essayez de le faire de manière asynchrone depuis l'envoi d'un e-mail est assez trivial et rapide de la tâche à effectuer. Je suppose que si vous envoyez des tonnes de courrier électronique et votre FAI bloque vous sur la suspicion de spam, qui pourrait être une des raisons de la file d'attente, mais d'autres que je ne peux pas penser à une raison pour faire de cette façon.