Existe-t-il un moyen réaliste d'implémenter un modèle multi-thread en PHP, que ce soit vraiment ou simplement en le simulant. Il y a quelque temps, il a été suggéré de forcer le système d'exploitation à charger une autre instance de l'exécutable PHP et à gérer d'autres processus simultanés.

Le problème avec cela est que lorsque le code PHP a fini d'exécuter l'instance PHP reste en mémoire car il n'y a aucun moyen de le tuer depuis PHP. Donc, si vous simulez plusieurs threads, vous pouvez imaginer ce qui va se passer. Je suis donc toujours à la recherche d'un moyen de faire du multi-threading ou de le simuler efficacement depuis PHP. Des idées?

Le multi-threading est possible en php

Oui, vous pouvez faire du multi-threading en PHP avec pthreads

De la documentation PHP :

pthreads est une API orientée objet qui fournit tous les outils nécessaires au multi-threading en PHP. Les applications PHP peuvent créer, lire, écrire, exécuter et synchroniser avec les objets Threads, Workers et Threaded.

Avertissement : L'extension pthreads ne peut pas être utilisée dans un environnement de serveur Web. Le threading en PHP devrait donc rester réservé aux applications CLI.

Test simple

#!/usr/bin/php
<?php
class AsyncOperation extends Thread {

    public function __construct($arg) {
        $this->arg = $arg;
    }

    public function run() {
        if ($this->arg) {
            $sleep = mt_rand(1, 10);
            printf('%s: %s  -start -sleeps %d' . "\n", date("g:i:sa"), $this->arg, $sleep);
            sleep($sleep);
            printf('%s: %s  -finish' . "\n", date("g:i:sa"), $this->arg);
        }
    }
}

// Create a array
$stack = array();

//Initiate Multiple Thread
foreach ( range("A", "D") as $i ) {
    $stack[] = new AsyncOperation($i);
}

// Start The Threads
foreach ( $stack as $t ) {
    $t->start();
}

?>

Première exécution

12:00:06pm:     A  -start -sleeps 5
12:00:06pm:     B  -start -sleeps 3
12:00:06pm:     C  -start -sleeps 10
12:00:06pm:     D  -start -sleeps 2
12:00:08pm:     D  -finish
12:00:09pm:     B  -finish
12:00:11pm:     A  -finish
12:00:16pm:     C  -finish

Deuxième manche

12:01:36pm:     A  -start -sleeps 6
12:01:36pm:     B  -start -sleeps 1
12:01:36pm:     C  -start -sleeps 2
12:01:36pm:     D  -start -sleeps 1
12:01:37pm:     B  -finish
12:01:37pm:     D  -finish
12:01:38pm:     C  -finish
12:01:42pm:     A  -finish

Exemple du monde réel

error_reporting(E_ALL);
class AsyncWebRequest extends Thread {
    public $url;
    public $data;

    public function __construct($url) {
        $this->url = $url;
    }

    public function run() {
        if (($url = $this->url)) {
            /*
             * If a large amount of data is being requested, you might want to
             * fsockopen and read using usleep in between reads
             */
            $this->data = file_get_contents($url);
        } else
            printf("Thread #%lu was not provided a URL\n", $this->getThreadId());
    }
}

$t = microtime(true);
$g = new AsyncWebRequest(sprintf("http://www.google.com/?q=%s", rand() * 10));
/* starting synchronization */
if ($g->start()) {
    printf("Request took %f seconds to start ", microtime(true) - $t);
    while ( $g->isRunning() ) {
        echo ".";
        usleep(100);
    }
    if ($g->join()) {
        printf(" and %f seconds to finish receiving %d bytes\n", microtime(true) - $t, strlen($g->data));
    } else
        printf(" and %f seconds to finish, request failed\n", microtime(true) - $t);
}

pourquoi n'utilisez-vous pas popen ?

for ($i=0; $i<10; $i++) {
    // open ten processes
    for ($j=0; $j<10; $j++) {
        $pipe[$j] = popen('script2.php', 'w');
    }

    // wait for them to finish
    for ($j=0; $j<10; ++$j) {
        pclose($pipe[$j]);
    }
}

Le filetage n'est pas disponible en stock PHP, mais une programmation simultanée est possible en utilisant des requêtes HTTP comme appels asynchrones.

Avec le paramètre de délai d'attente de la boucle défini sur 1 et en utilisant le même identifiant de session pour les processus que vous souhaitez associer les uns aux autres, vous pouvez communiquer avec des variables de session comme dans mon exemple ci-dessous. Avec cette méthode, vous pouvez même fermer votre navigateur et le processus simultané existe toujours sur le serveur.

N'oubliez pas de vérifier l'ID de session correct comme ceci:

http: //localhost/test/verifysession.php? sessionid = [l' identifiant correct]

startprocess.php

$request = "http://localhost/test/process1.php?sessionid=".$_REQUEST["PHPSESSID"];
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $request);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_TIMEOUT, 1);
curl_exec($ch);
curl_close($ch);
echo $_REQUEST["PHPSESSID"];

process1.php

set_time_limit(0);

if ($_REQUEST["sessionid"])
   session_id($_REQUEST["sessionid"]);

function checkclose()
{
   global $_SESSION;
   if ($_SESSION["closesession"])
   {
       unset($_SESSION["closesession"]);
       die();
   }
}

while(!$close)
{
   session_start();
   $_SESSION["test"] = rand();
   checkclose();
   session_write_close();
   sleep(5);
}

verifysession.php

if ($_REQUEST["sessionid"])
    session_id($_REQUEST["sessionid"]);

session_start();
var_dump($_SESSION);

closeprocess.php

if ($_REQUEST["sessionid"])
    session_id($_REQUEST["sessionid"]);

session_start();
$_SESSION["closesession"] = true;
var_dump($_SESSION);

Bien que vous ne puissiez pas enfiler, vous avez un certain degré de contrôle de processus en php. Les deux jeux de fonctions utiles ici sont:

Fonctions de contrôle de processus http://www.php.net/manual/en/ref.pcntl.php

Fonctions POSIX http://www.php.net/manual/en/ref.posix.php

Vous pouvez bifurquer votre processus avec pcntl_fork - renvoyant le PID de l'enfant. Ensuite, vous pouvez utiliser posix_kill pour supprimer ce PID.

Cela dit, si vous tuez un processus parent, un signal doit être envoyé au processus enfant lui disant de mourir. Si php lui-même ne le reconnaît pas, vous pouvez enregistrer une fonction pour le gérer et faire une sortie propre en utilisant pcntl_signal.

l'utilisation de threads est rendue possible par l'extension pthreads PECL

http://www.php.net/manual/en/book.pthreads.php

Je sais que c'est une vieille question mais pour les personnes qui recherchent, il y a une extension PECL écrite en C qui donne maintenant la capacité de multi-threading PHP, elle est située ici https://github.com/krakjoe/pthreads

Vous pouvez utiliser exec () pour exécuter un script de ligne de commande (tel que la ligne de commande php), et si vous dirigez la sortie vers un fichier, votre script n'attendra pas la fin de la commande.

Je ne me souviens pas vraiment de la syntaxe php CLI, mais vous voudriez quelque chose comme:

exec("/path/to/php -f '/path/to/file.php' | '/path/to/output.txt'");

Je pense que bon nombre de serveurs d'hébergement partagé ont désactivé exec () par défaut pour des raisons de sécurité, mais cela pourrait valoir la peine d'essayer.

Vous pouvez simuler le filetage. PHP peut exécuter des processus d'arrière-plan via popen (ou proc_open). Ces processus peuvent être communiqués via stdin et stdout. Bien sûr, ces processus peuvent eux-mêmes être un programme php. C'est probablement aussi proche que possible.

Selon ce que vous essayez de faire, vous pouvez également utiliser curl_multi pour y parvenir.

Je sais que c'est bien vieux, mais vous pouvez regarder http://phpthreadlib.sourceforge.net/

Il prend en charge la communication bidirectionnelle entre les threads et dispose également de protections intégrées pour éliminer les threads enfants (empêcher les orphelins).

Vous pouvez avoir l'option de:

1. multi_curl
2. On peut utiliser la commande système pour le même
3. Le scénario idéal est de créer une fonction de threading en langage C et de compiler / configurer en PHP. Maintenant, cette fonction sera la fonction de PHP.

La classe Thread est disponible depuis les pthreads PECL ≥ 2.0.0.

Que diriez-vous de pcntl_fork?

consultez notre page de manuel pour des exemples: PHP pcntl_fork

<?php

    $pid = pcntl_fork();
    if ($pid == -1) {
        die('could not fork');
    } else if ($pid) {
        // we are the parent
        pcntl_wait($status); //Protect against Zombie children
    } else {
        // we are the child
    }

?>

pcntl_forkne fonctionnera pas dans un environnement de serveur Web si le mode sans échec est activé. Dans ce cas, cela ne fonctionnera que dans la version CLI de PHP.

Si vous utilisez un serveur Linux, vous pouvez utiliser

exec("nohup $php_path path/script.php > /dev/null 2>/dev/null &")

Si vous avez besoin de passer quelques arguments

exec("nohup $php_path path/script.php $args > /dev/null 2>/dev/null &")

Dans script.php

$args = $argv[1];

Ou utilisez Symfony https://symfony.com/doc/current/components/process.html

$process = Process::fromShellCommandline("php ".base_path('script.php'));
$process->setTimeout(0);     
$process->disableOutput();     
$process->start();

Au moment de la rédaction de mon commentaire actuel, je ne connaissais pas les threads PHP. Je suis venu chercher la réponse ici moi-même, mais une solution de contournement est que le programme PHP qui reçoit la demande du serveur Web délègue toute la formulation de la réponse à une application console qui stocke sa sortie, la réponse à la demande, à un fichier binaire et le programme PHP qui a lancé l'application console renvoie ce fichier binaire octet par octet comme réponse à la demande reçue. L'application console peut être écrite dans n'importe quel langage de programmation qui s'exécute sur le serveur, y compris ceux qui ont une prise en charge de thread appropriée, y compris les programmes C ++ qui utilisent OpenMP.

Une astuce peu fiable et sale consiste à utiliser PHP pour exécuter une application console, "uname",

uname -a

et imprimez la sortie de cette commande de console dans la sortie HTML pour connaître la version exacte du logiciel serveur. Ensuite, installez la même version exacte du logiciel sur une instance de VirtualBox, compilez / assemblez les binaires entièrement autonomes, de préférence statiques, que vous souhaitez, puis téléchargez-les sur le serveur. À partir de ce moment, l'application PHP peut utiliser ces fichiers binaires dans le rôle de l'application console qui a le multi-threading approprié. C'est une solution de contournement sale et peu fiable à une situation où l'administrateur du serveur n'a pas installé toutes les implémentations de langage de programmation nécessaires sur le serveur. La chose à surveiller est qu'à chaque demande que l'application PHP reçoive la ou les applications de console se termine / exit / get_killed.

Quant à ce que les administrateurs de services d'hébergement pensent de ces modèles d'utilisation du serveur, je suppose que cela se résume à la culture. En Europe du Nord, le fournisseur de services DOIT LIVRER CE QUI A ÉTÉ ANNONCÉ et si l'exécution des commandes de la console a été autorisée et le téléchargement de fichiers non malveillants a été autorisé et le fournisseur de services a le droit de tuer tout processus de serveur après quelques minutes ou même après 30 secondes , alors les administrateurs du service d'hébergement n'ont aucun argument pour former une plainte appropriée. Aux États-Unis et en Europe occidentale, la situation / culture est très différente et je pense qu'il y a de grandes chances qu'aux États-Unis et / ou en Europe occidentale, le fournisseur de services d'hébergement refuse de servir les clients de services d'hébergement qui utilisent l'astuce décrite ci-dessus. C'est juste ma supposition, étant donné mon expérience personnelle avec les États-Unis services d'hébergement et compte tenu de ce que j'ai entendu d'autres sur les services d'hébergement en Europe occidentale. Au moment de la rédaction de mon commentaire actuel (2018_09_01), je ne connaissais rien aux normes culturelles des hébergeurs sud-européens, administrateurs de réseaux sud-européens.

Peut-être que j'ai raté quelque chose, mais l'exec n'a pas fonctionné comme asynchrone pour moi dans l'environnement Windows que j'ai utilisé dans Windows et cela a fonctionné comme un charme;)

$script_exec = "c:/php/php.exe c:/path/my_ascyn_script.php";

pclose(popen("start /B ". $script_exec, "r"));

Le multithreading signifie effectuer plusieurs tâches ou processus simultanément, nous pouvons y parvenir en php en utilisant le code suivant, bien qu'il n'y ait pas de moyen direct de réaliser le multithreading en php mais nous pouvons obtenir presque les mêmes résultats en suivant le chemin.

chdir(dirname(__FILE__));  //if you want to run this file as cron job
 for ($i = 0; $i < 2; $i += 1){
 exec("php test_1.php $i > test.txt &");
 //this will execute test_1.php and will leave this process executing in the background and will go         

 //to next iteration of the loop immediately without waiting the completion of the script in the   

 //test_1.php , $i  is passed as argument .

}

Test_1.php

$conn=mysql_connect($host,$user,$pass);
$db=mysql_select_db($db);
$i = $argv[1];  //this is the argument passed from index.php file
for($j = 0;$j<5000; $j ++)
{
mysql_query("insert  into  test   set

                id='$i',

                comment='test',

                datetime=NOW() ");

}

Cela exécutera test_1.php deux fois simultanément et les deux processus s'exécuteront en arrière-plan simultanément, de cette façon, vous pouvez réaliser le multithreading en php.

Ce gars a fait du très bon travail Multithreading en php