pcntl_wait

(PHP 5, PHP 7)

pcntl_waitWaits on or returns the status of a forked child

Описание

int pcntl_wait ( int &$status [, int $options = 0 ] )

The wait function suspends execution of the current process until a child has exited, or until a signal is delivered whose action is to terminate the current process or to call a signal handling function. If a child has already exited by the time of the call (a so-called "zombie" process), the function returns immediately. Any system resources used by the child are freed. Please see your system's wait(2) man page for specific details as to how wait works on your system.

Замечание:

This function is equivalent to calling pcntl_waitpid() with a -1 pid and no options.

Список параметров

status

pcntl_wait() will store status information in the status parameter which can be evaluated using the following functions: pcntl_wifexited(), pcntl_wifstopped(), pcntl_wifsignaled(), pcntl_wexitstatus(), pcntl_wtermsig() and pcntl_wstopsig().

options

If wait3 is available on your system (mostly BSD-style systems), you can provide the optional options parameter. If this parameter is not provided, wait will be used for the system call. If wait3 is not available, providing a value for options will have no effect. The value of options is the value of zero or more of the following two constants OR'ed together:

Possible values for options
WNOHANG Return immediately if no child has exited.
WUNTRACED Return for children which are stopped, and whose status has not been reported.

Возвращаемые значения

pcntl_wait() returns the process ID of the child which exited, -1 on error or zero if WNOHANG was provided as an option (on wait3-available systems) and no child was available.

Смотрите также

Коментарии

Below is a simple example of forking some children and timing the total duration (useful for stress tests).

<?php

$isParent   
true;
$children    = array();
$start        microtimetrue);

/* Fork you!
 * (Sorry, I had to)
 */
$ceiling $CONCURRENCY 1;

for ( 
$i 0; (( $i $ceiling) && ( $isParent)); $i++) {
   
$pid pcntl_fork();
    if ( 
$pid === 0) {
       
$isParent false;
       
    } elseif ( 
$pid != -1) {
       
$children[] = $pid;
       
    }

}

/* Process body */
echo "Do stuff here\n";

/* Cleanup */
if ( $isParent) {
   
$status null;
    while ( 
count$children)) {
       
pcntl_wait$status);
       
array_pop$children);
    }
   
    echo 
"Completed in " . ( microtimetrue) - $start) . " seconds.\n";
   
}

?>
2005-10-19 10:14:58
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html
This a simple multi process application where you can choose 
the maximun process that can run at the same time.
This is useful when you need to limit the fork of process.
When the MAXPROCESS is reached the program wait on pcntl_wait()

<?php

DEFINE
(MAXPROCESS,25);

for (
$i=0;$i<100;$i++){
   
$pid pcntl_fork();
   
    if (
$pid == -1) {
       die(
"could not fork");
    } elseif (
$pid) {
                echo 
"I'm the Parent $i\n";
       
$execute++;
        if (
$execute>=MAXPROCESS){
           
pcntl_wait($status);
           
$execute--;
        }
    } else {
       echo 
"I am the child, $i pid = $pid \n";
       
sleep(rand(1,3));
       echo 
"Bye Bye from $i\n";       
       exit;
    }
}
?>
2006-02-19 18:39:08
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html
The code before isnt working for me cause the children are correctly started but not refreshed after they died. So keep in mind to use this instead and use the signal handler to know when a child exits to know when you have to start a new one. I added a few lines to the posting from {andy at cbeyond dot net} cause his post wasnt working for me as well (PHP5.1). Same effect like the one below.

<?php
declare(ticks 1);

$max=5;
$child=0;

// function for signal handler
function sig_handler($signo) {
  global 
$child;
  switch (
$signo) {
   case 
SIGCHLD:
     echo 
"SIGCHLD received\n";
     
$child--;
  }
}

// install signal handler for dead kids
pcntl_signal(SIGCHLD"sig_handler");

while (
1){
       
$child++;
       
$pid=pcntl_fork();
       
       if (
$pid == -1) {
               die(
"could not fork");
       } else if (
$pid) {
               
               
// we are the parent
               
if ( $child >= $max ){
                   
pcntl_wait($status);
                   
$child++;
               }
       } else {
               
// we are the child
               
echo "\t Starting new child | now we de have $child child processes\n";
               
// presumably doing something interesting
               
sleep(rand(3,5));
               exit;
       }
}
?>
2006-03-24 13:19:52
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html
pcntl_wait will not terminate on signals if you have a PHP signal handler activated (pcntl_signal).
This is unless the signal handler was activated with 3rd parameter=true.

Example:
<?php
declare(ticks=1);
pcntl_signal(SIGTERM"myHandler");
$pid=pcntl_wait($status);
?>

This will not terminate on SIGTERM sent to the process, because "wait" will be restarted after php recieves the signal. The signal handler "myHandler" will not be called unless pcntl_wait terminates for some other reason.

Change to:
<?php
declare(ticks=1);
pcntl_signal(SIGTERM"myHandler"true);
$pid=pcntl_wait($status);
?>

Now the pcntl_wait terminates when a signal comes in and "myHandler" will be called on SIGTERM. (Make sure to put the wait in a loop though, because it will now not only terminate when a child exits but also when a signal arrives. Test for $pid>0 to detect a exit message from a child)
(thanks to Andrey for helping me debugging this)
2010-06-16 08:17:12
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html
I was unable to get pcntl_wait or pcntl_waitpid to terminate when I had an active signal handler.  I then noticed the post below from gaylord at 100days dot de, however I'm a little confused by that post as I found the exact opposite to be true.  The default value of the third parameter of pcntl_signal (the restart_syscalls parameter) is true and this seems to cause the wait to continue when the signal arrives.  In order to prevent this I had to expressly set it to false.  That is:

pcntl_signal(SIGTERM, 'my_handler_function', false);
2010-06-21 17:44:27
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html
Using pcntl_fork() can be a little tricky in some situations.  For fast jobs, a child can finish processing before the parent process has executed some code related to the launching of the process.  The parent can receive a signal before it's ready to handle the child process' status.  To handle this scenario, I add an id to a "queue" of processes in the signal handler that need to be cleaned up if the parent process is not yet ready to handle them.

<?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);
           
$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$statusWNOHANG);
        }
       
       
//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$statusWNOHANG);
        }
        return 
true;
    }
}
2010-07-01 21:45:38
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html
Oops, I stripped just a little much from the job daemon code in the previous comment.  You'll want to add a little line before the ->launchJob() method is called:

<?php

while(count($this->currentJobs) >= $this->maxProcesses){
    echo 
"Maximum children allowed, waiting...\n";
   
sleep(1); 
}
2010-07-01 22:12:57
http://php5.kiev.ua/manual/ru/function.pcntl-wait.html

    Поддержать сайт на родительском проекте КГБ