L'exécution des fonctions en parallèle

Le seul temps d'attente vous souffrez entre l'obtention de données et de traitement de données. Le traitement des données est en réalité complètement le blocage de toute façon (il vous suffit simplement d'attendre qu'il). Vous ne sera probablement pas obtenir des avantages, passé augmentant le nombre de processus pour le nombre de cœurs que vous avez. Fondamentalement, je pense que cela signifie que le nombre de processus est petit, de sorte que la planification de l'exécution de 2-8 processus n'a pas l'air si affreux. Si vous êtes inquiet de ne pas être en mesure de traiter des données lors de la récupération de données, vous pourriez en théorie accéder à vos données à partir de la base de données dans de petits blocs, puis répartir la charge de traitement entre quelques processus, un pour chaque core.

Je pense que j'aligne plus avec la fourche de processus enfant approche pour exécuter le traitement de threads. Il en est une brillante démonstration dans les commentaires sur le pcntl_fork doc page montrant une mise en œuvre d'un travail de classe démon

http://php.net/manual/en/function.pcntl-fork.php

<?php 
declare(ticks=1); 
//A very basic job daemon that you can extend to your needs. 
class JobDaemon{ 
public $maxProcesses = 25; 
protected $jobsStarted = 0; 
protected $currentJobs = array(); 
protected $signalQueue=array();   
protected $parentPID; 
public function __construct(){ 
echo "constructed \n"; 
$this->parentPID = getmypid(); 
pcntl_signal(SIGCHLD, array($this, "childSignalHandler")); 
} 
/** 
* Run the Daemon 
*/ 
public function run(){ 
echo "Running \n"; 
for($i=0; $i<10000; $i++){ 
$jobID = rand(0,10000000000000); 
while(count($this->currentJobs) >= $this->maxProcesses){ 
echo "Maximum children allowed, waiting...\n"; 
sleep(1); 
} 
$launched = $this->launchJob($jobID); 
} 
//Wait for child processes to finish before exiting here 
while(count($this->currentJobs)){ 
echo "Waiting for current jobs to finish... \n"; 
sleep(1); 
} 
} 
/** 
* Launch a job from the job queue 
*/ 
protected function launchJob($jobID){ 
$pid = pcntl_fork(); 
if($pid == -1){ 
//Problem launching the job 
error_log('Could not launch new job, exiting'); 
return false; 
} 
else if ($pid){ 
//Parent process 
//Sometimes you can receive a signal to the childSignalHandler function before this code executes if 
//the child script executes quickly enough! 
//
$this->currentJobs[$pid] = $jobID; 
//In the event that a signal for this pid was caught before we get here, it will be in our signalQueue array 
//So let's go ahead and process it now as if we'd just received the signal 
if(isset($this->signalQueue[$pid])){ 
echo "found $pid in the signal queue, processing it now \n"; 
$this->childSignalHandler(SIGCHLD, $pid, $this->signalQueue[$pid]); 
unset($this->signalQueue[$pid]); 
} 
} 
else{ 
//Forked child, do your deeds.... 
$exitStatus = 0; //Error code if you need to or whatever 
echo "Doing something fun in pid ".getmypid()."\n"; 
exit($exitStatus); 
} 
return true; 
} 
public function childSignalHandler($signo, $pid=null, $status=null){ 
//If no pid is provided, that means we're getting the signal from the system.  Let's figure out 
//which child process ended 
if(!$pid){ 
$pid = pcntl_waitpid(-1, $status, WNOHANG); 
} 
//Make sure we get all of the exited children 
while($pid > 0){ 
if($pid && isset($this->currentJobs[$pid])){ 
$exitCode = pcntl_wexitstatus($status); 
if($exitCode != 0){ 
echo "$pid exited with status ".$exitCode."\n"; 
} 
unset($this->currentJobs[$pid]); 
} 
else if($pid){ 
//Oh no, our job has finished before this parent process could even note that it had been launched! 
//Let's make note of it and handle it when the parent process is ready for it 
echo "..... Adding $pid to the signal queue ..... \n"; 
$this->signalQueue[$pid] = $status; 
} 
$pid = pcntl_waitpid(-1, $status, WNOHANG); 
} 
return true; 
} 
}

OriginalL'auteur Matt Esch

Ont un coup d'oeil à pcntl_fork. Cela vous permet de vous frayer processus enfant qui peut alors faire le travail distinct que vous avez besoin.

OriginalL'auteur Jim