这篇文章主要介绍了以实例全面讲解PHP中多进程编程的相关函数的使用,包括对僵尸进程的处理等方面,极力推荐!需要的朋友可以参考下。

PHP有一组进程控制函数(编译时需要–enable-pcntl与posix扩展)，使得php能实现跟c一样的创建子进程、使用exec函数执行程序、处理信号等功能。

1. <?php  
2.   header('content-type:text/html;charset=utf-8' );  
3.      
4.   // 必须加载扩展  
5.   if (!function_exists("pcntl_fork")) {  
6.     die("pcntl extention is must !");  
7.   }  
8.   //总进程的数量  
9.   $totals = 3;  
10.   // 执行的脚本数量  
11.   $cmdArr = array();  
12.   // 执行的脚本数量的数组  
13.   for ($i = 0; $i < $totals; $i++) {  
14.     $cmdArr[] = array("path" => __DIR__ . "/run.php", 'pid' =>$i ,'total' =>$totals);  
15.   }  
16.      
17.   /*  
18.   展开：$cmdArr  
19.   Array  
20.   (  
21.     [0] => Array  
22.       (  
23.         [path] => /var/www/html/company/pcntl/run.php  
24.         [pid] => 0  
25.         [total] => 3  
26.       )  
27.      
28.     [1] => Array  
29.       (  
30.         [path] => /var/www/html/company/pcntl/run.php  
31.         [pid] => 1  
32.         [total] => 3  
33.       )  
34.      
35.     [2] => Array  
36.       (  
37.         [path] => /var/www/html/company/pcntl/run.php  
38.         [pid] => 2  
39.         [total] => 3  
40.       )  
41.      
42.   )  
43.   */ 
44.      
45.   pcntl_signal(SIGCHLD, SIG_IGN); //如果父进程不关心子进程什么时候结束,子进程结束后，内核会回收。  
46.   foreach ($cmdArr as  $cmd) {  
47.     $pid = pcntl_fork();  //创建子进程  
48.     //父进程和子进程都会执行下面代码  
49.     if ($pid == -1) {  
50.       //错误处理：创建子进程失败时返回-1.  
51.       die('could not fork');  
52.     } else if ($pid) {  
53.       //父进程会得到子进程号，所以这里是父进程执行的逻辑  
54.       //如果不需要阻塞进程，而又想得到子进程的退出状态，则可以注释掉pcntl_wait($status)语句，或写成：  
55.       pcntl_wait($status,WNOHANG); //等待子进程中断，防止子进程成为僵尸进程。  
56.     } else {  
57.       //子进程得到的$pid为0, 所以这里是子进程执行的逻辑。  
58.       $path  = $cmd["path"];  
59.       $pid = $cmd['pid'] ;  
60.       $total = $cmd['total'] ;  
61.       echo exec("/usr/bin/php {$path} {$pid} {$total}")."\n";  
62.       exit(0) ;  
63.     }  
64.   }  
65.   ?> 

使用PHP真正的多进程运行模式，适用于数据采集、邮件群发、数据源更新、tcp服务器等环节。

PHP有一组进程控制函数(编译时需要 –enable-pcntl与posix扩展)，使得php能在*nix系统中实现跟c一样的创建子进程、使用exec函数执行程序、处理信号等功能。 PCNTL使用ticks来作为信号处理机制（signal handle callback mechanism），可以最小程度地降低处理异步事件时的负载。何谓ticks？Tick 是一个在代码段中解释器每执行 N 条低级语句就会发生的事件，这个代码段需要通过declare来指定。

常用的PCNTL函数

1. pcntl_alarm ( int $seconds )

设置一个$seconds秒后发送SIGALRM信号的计数器

2. pcntl_signal ( int $signo , callback $handler [, bool $restart_syscalls ] )

为$signo设置一个处理该信号的回调函数。下面是一个隔5秒发送一个SIGALRM信号，并由signal_handler函数获取，然后打印一个“Caught SIGALRM”的例子：

1. <?php 
2. declare(ticks = 1); 
3.    
4. function signal_handler($signal) { 
5.   print "Caught SIGALRM\n"; 
6.   pcntl_alarm(5); 
7. } 
8.    
9. pcntl_signal(SIGALRM, "signal_handler", true); 
10. pcntl_alarm(5); 
11.    
12. for(;;) { 
13. } 
14.    
15. ?> 

3. pcntl_exec ( string $path [, array $args [, array $envs ]] )

在当前的进程空间中执行指定程序，类似于c中的exec族函数。所谓当前空间，即载入指定程序的代码覆盖掉当前进程的空间，执行完该程序进程即结束。

1. <?php 
2. $dir = '/home/shankka/'; 
3. $cmd = 'ls'; 
4. $option = '-l'; 
5. $pathtobin = '/bin/ls'; 
6.    
7. $arg = array($cmd, $option, $dir); 
8.    
9. pcntl_exec($pathtobin, $arg); 
10. echo '123';  //不会执行到该行 
11. ?> 

4. pcntl_fork ( void )

为当前进程创建一个子进程，并且先运行父进程，返回的是子进程的PID，肯定大于零。在父进程的代码中可以用 pcntl_wait（&$status）暂停父进程知道他的子进程有返回值。注意：父进程的阻塞同时会阻塞子进程。但是父进程的结束不影响子进程的运行。

父进程运行完了会接着运行子进程，这时子进程会从执行pcntl_fork（）的那条语句开始执行（包括此函数），但是此时它返回的是零（代表这是一个子进程）。在子进程的代码块中最好有exit语句，即执行完子进程后立即就结束。否则它会又重头开始执行这个脚本的某些部分。

注意两点：

子进程最好有一个exit；语句，防止不必要的出错；

pcntl_fork间最好不要有其它语句，例如：

1. <?php 
2. $pid = pcntl_fork(); 
3. //这里最好不要有其他的语句 
4. if ($pid == -1) { 
5.   die('could not fork'); 
6. } else if ($pid) { 
7.   // we are the parent 
8. pcntl_wait($status); //Protect against Zombie children 
9. } else { 
10.   // we are the child 
11. } 
12. ?> 

5. pcntl_wait ( int &$status [, int $options ] )

阻塞当前进程，只到当前进程的一个子进程退出或者收到一个结束当前进程的信号。使用$status返回子进程的状态码，并可以指定第二个参数来说明是否以阻塞状态调用：

阻塞方式调用的，函数返回值为子进程的pid,如果没有子进程返回值为-1；

非阻塞方式调用，函数还可以在有子进程在运行但没有结束的子进程时返回0。

6. pcntl_waitpid ( int $pid , int &$status [, int $options ] )

功能同pcntl_wait，区别为waitpid为等待指定pid的子进程。当pid为-1时pcntl_waitpid与pcntl_wait 一样。在pcntl_wait和pcntl_waitpid两个函数中的$status中存了子进程的状态信息，这个参数可以用于 pcntl_wifexited、pcntl_wifstopped、pcntl_wifsignaled、pcntl_wexitstatus、 pcntl_wtermsig、pcntl_wstopsig、pcntl_waitpid这些函数。

例如：

1. <?php 
2. $pid = pcntl_fork(); 
3. if($pid) { 
4.   pcntl_wait($status); 
5.   $id = getmypid(); 
6.   echo "parent process,pid {$id}, child pid {$pid}\n"; 
7. }else{ 
8.   $id = getmypid(); 
9.   echo "child process,pid {$id}\n"; 
10.   sleep(2); 
11. } 
12. ?> 

子进程在输出child process等字样之后sleep了2秒才结束，而父进程阻塞着直到子进程退出之后才继续运行。

7. pcntl_getpriority ([ int $pid [, int $process_identifier ]] )

取得进程的优先级，即nice值，默认为0，在我的测试环境的linux中（CentOS release 5.2 (Final)），优先级为-20到19，-20为优先级最高，19为最低。（手册中为-20到20）。

8. pcntl_setpriority ( int $priority [, int $pid [, int $process_identifier ]] )

设置进程的优先级。

9. posix_kill

可以给进程发送信号

10. pcntl_singal

用来设置信号的回调函数

当父进程退出时，子进程如何得知父进程的退出

当父进程退出时，子进程一般可以通过下面这两个比较简单的方法得知父进程已经退出这个消息：

当父进程退出时，会有一个INIT进程来领养这个子进程。这个INIT进程的进程号为1，所以子进程可以通过使用getppid()来取得当前父进程的pid。如果返回的是1，表明父进程已经变为INIT进程，则原进程已经推出。

使用kill函数，向原有的父进程发送空信号（kill(pid, 0)）。使用这个方法对某个进程的存在性进行检查，而不会真的发送信号。所以，如果这个函数返回-1表示父进程已经退出。

除了上面的这两个方法外，还有一些实现上比较复杂的方法，比如建立管道或socket来进行时时的监控等等。

PHP多进程采集数据的例子

1. <?php 
2. /** 
3. * Project: Signfork: php多线程库 
4. * File:  Signfork.class.php 
5. */ 
6.    
7. class Signfork{ 
8.  /** 
9.   * 设置子进程通信文件所在目录 
10.   * @var string 
11.   */ 
12.  private $tmp_path='/tmp/'; 
13.    
14. /** 
15.  * Signfork引擎主启动方法 
16.  * 1、判断$arg类型,类型为数组时将值传递给每个子进程;类型为数值型时,代表要创建的进程数. 
17.  * @param object $obj 执行对象 
18.  * @param string&#124;array $arg 用于对象中的__fork方法所执行的参数 
19.  * 如:$arg,自动分解为:$obj->__fork($arg[0])、$obj->__fork($arg[1])... 
20.  * @return array 返回  array(子进程序列=>子进程执行结果); 
21.  */ 
22.  public function run($obj,$arg=1){ 
23.   if(!method_exists($obj,'__fork')){ 
24.    exit("Method '__fork' not found!"); 
25.   } 
26.    
27.   if(is_array($arg)){ 
28.    $i=0; 
29.    foreach($arg as $key=>$val){ 
30.     $spawns[$i]=$key; 
31.     $i++; 
32.     $this->spawn($obj,$key,$val); 
33.    } 
34.    $spawns['total']=$i; 
35.   }elseif($spawns=intval($arg)){ 
36.    for($i = 0; $i < $spawns; $i++){ 
37.     $this->spawn($obj,$i); 
38.    } 
39.   }else{ 
40.    exit('Bad argument!'); 
41.   } 
42.    
43.   if($i>1000) exit('Too many spawns!'); 
44.    return $this->request($spawns); 
45.   } 
46.    
47.  /** 
48.   * Signfork主进程控制方法 
49.   * 1、$tmpfile 判断子进程文件是否存在，存在则子进程执行完毕，并读取内容 
50.   * 2、$data收集子进程运行结果及数据，并用于最终返回 
51.   * 3、删除子进程文件 
52.   * 4、轮询一次0.03秒，直到所有子进程执行完毕，清理子进程资源 
53.   * @param string&#124;array $arg 用于对应每个子进程的ID 
54.   * @return array 返回  array([子进程序列]=>[子进程执行结果]); 
55.   */ 
56.   private function request($spawns){ 
57.    $data=array(); 
58.    $i=is_array($spawns)?$spawns['total']:$spawns; 
59.    for($ids = 0; $ids<$i; $ids++){ 
60.     while(!($cid=pcntl_waitpid(-1, $status, WNOHANG)))usleep(30000); 
61.     $tmpfile=$this->tmp_path.'sfpid_'.$cid; 
62.     $data[$spawns['total']?$spawns[$ids]:$ids]=file_get_contents($tmpfile); 
63.     unlink($tmpfile); 
64.    } 
65.    return $data; 
66.   } 
67.    
68. /** 
69.  * Signfork子进程执行方法 
70.  * 1、pcntl_fork 生成子进程 
71.  * 2、file_put_contents 将'$obj->__fork($val)'的执行结果存入特定序列命名的文本 
72.  * 3、posix_kill杀死当前进程 
73.  * @param object $obj    待执行的对象 
74.  * @param object $i        子进程的序列ID，以便于返回对应每个子进程数据 
75.  * @param object $param 用于输入对象$obj方法'__fork'执行参数 
76.  */ 
77.  private function spawn($obj,$i,$param=null){ 
78.   if(pcntl_fork()===0){ 
79.    $cid=getmypid(); 
80.    file_put_contents($this->tmp_path.'sfpid_'.$cid,$obj->__fork($param)); 
81.    posix_kill($cid, SIGTERM); 
82.    exit; 
83.   } 
84.  } 
85. } 
86. ?> 

php在pcntl_fork()后生成的子进程(通常为僵尸进程)必须由pcntl_waitpid()函数进行资源释放。但在 pcntl_waitpid()不一定释放的就是当前运行的进程，也可能是过去生成的僵尸进程(没有释放)；也可能是并发时其它访问者的僵尸进程。但可以使用posix_kill($cid, SIGTERM)在子进程结束时杀掉它。

子进程会自动复制父进程空间里的变量。

PHP多进程编程示例2

1. <?php 
2. //..... 
3. //需要安装pcntl的php扩展，并加载它 
4. if(function_exists("pcntl_fork")){ 
5.   //生成子进程 
6.  $pid = pcntl_fork(); 
7.  if($pid == -1){ 
8.   die('could not fork'); 
9.  }else{ 
10.   if($pid){ 
11.    $status = 0; 
12.    //阻塞父进程，直到子进程结束，不适合需要长时间运行的脚本，可使用pcntl_wait($status, 0)实现非阻塞式 
13.    pcntl_wait($status); 
14.    // parent proc code 
15.    exit; 
16.   }else{ 
17.    // child proc code 
18.    //结束当前子进程，以防止生成僵尸进程 
19.    if(function_exists("posix_kill")){ 
20.     posix_kill(getmypid(), SIGTERM); 
21.    }else{ 
22.     system('kill -9'. getmypid()); 
23.    } 
24.    exit; 
25.   } 
26.  } 
27. }else{ 
28.   // 不支持多进程处理时的代码在这里 
29. } 
30. //..... 
31. ?> 

如果不需要阻塞进程，而又想得到子进程的退出状态，则可以注释掉pcntl_wait($status)语句，或写成：

1. <?php 
2. pcntl_wait($status, 1); 
3. //或 
4. pcntl_wait($status, WNOHANG); 
5. ?> 

在上面的代码中，如果父进程退出(使用exit函数退出或redirect)，则会导致子进程成为僵尸进程(会交给init进程控制)，子进程不再执行。

僵尸进程是指的父进程已经退出,而该进程dead之后没有进程接受,就成为僵尸进程.(zombie)进程。任何进程在退出前(使用exit退出) 都会变成僵尸进程(用于保存进程的状态等信息)，然后由init进程接管。如果不及时回收僵尸进程，那么它在系统中就会占用一个进程表项，如果这种僵尸进程过多，最后系统就没有可以用的进程表项，于是也无法再运行其它的程序。

预防僵尸进程有以下几种方法：

1. 父进程通过wait和waitpid等函数使其等待子进程结束，然后再执行父进程中的代码，这会导致父进程挂起。上面的代码就是使用这种方式实现的，但在WEB环境下，它不适合子进程需要长时间运行的情况(会导致超时)。

使用wait和waitpid方法使父进程自动回收其僵尸子进程(根据子进程的返回状态)，waitpid用于临控指定子进程，wait是对于所有子进程而言。

2. 如果父进程很忙，那么可以用signal函数为SIGCHLD安装handler，因为子进程结束后，父进程会收到该信号，可以在handler中调用wait回收

3. 如果父进程不关心子进程什么时候结束，那么可以用signal(SIGCHLD, SIG_IGN)通知内核，自己对子进程的结束不感兴趣，那么子进程结束后，内核会回收，并不再给父进程发送信号，例如：

1. <?php 
2. pcntl_signal(SIGCHLD, SIG_IGN); 
3. $pid = pcntl_fork(); 
4. //....code 
5. ?> 

4. 还有一个技巧，就是fork两次，父进程fork一个子进程，然后继续工作，子进程再fork一个孙进程后退出，那么孙进程被init接管，孙进程结束后，init会回收。不过子进程的回收还要自己做。下面是一个例子：

1. #include "apue.h" 
2. #include <sys/wait.h> 
3.    
4. int main(void){ 
5. pid_t  pid; 
6.    
7. if ((pid = fork()) < 0){ 
8.   err_sys("fork error"); 
9. } else if (pid == 0){   /**//* first child */ 
10.  if ((pid = fork()) < 0){ 
11.    err_sys("fork error"); 
12.  }elseif(pid > 0){ 
13.    exit(0);  /**//* parent from second fork == first child */ 
14.  } 
15.    
16.  /** 
17.   * We're the second child; our parent becomes init as soon 
18.   * as our real parent calls exit() in the statement above. 
19.   * Here's where we'd continue executing, knowing that when 
20.   * we're done, init will reap our status. 
21.   */ 
22.   sleep(2); 
23.   printf("second child, parent pid = %d ", getppid()); 
24.   exit(0); 
25. } 
26.    
27. if (waitpid(pid, NULL, 0) != pid) /**//* wait for first child */ 
28.  err_sys("waitpid error"); 
29.    
30. /** 
31.  * We're the parent (the original process); we continue executing, 
32.  * knowing that we're not the parent of the second child. 
33.  */ 
34.  exit(0); 
35. } 

在fork()/execve()过程中，假设子进程结束时父进程仍存在，而父进程fork()之前既没安装SIGCHLD信号处理函数调用 waitpid()等待子进程结束，又没有显式忽略该信号，则子进程成为僵尸进程，无法正常结束，此时即使是root身份kill-9也不能杀死僵尸进程。补救办法是杀死僵尸进程的父进程(僵尸进程的父进程必然存在)，僵尸进程成为”孤儿进程”，过继给1号进程init，init会定期调用wait回收清理这些父进程已退出的僵尸子进程。

所以，上面的示例可以改成：

1. <?php 
2. //..... 
3. //需要安装pcntl的php扩展，并加载它 
4. if(function_exists("pcntl_fork")){ 
5.  //生成第一个子进程 
6. $pid = pcntl_fork(); //$pid即所产生的子进程id 
7. if($pid == -1){ 
8.  //子进程fork失败 
9.  die('could not fork'); 
10. }else{ 
11.  if($pid){ 
12.   //父进程code 
13.   sleep(5); //等待5秒 
14.   exit(0); //或$this->_redirect('/'); 
15.  }else{ 
16.   //第一个子进程code 
17.   //产生孙进程 
18.   if(($gpid = pcntl_fork()) < 0){ ////$gpid即所产生的孙进程id 
19.    //孙进程产生失败 
20.    die('could not fork'); 
21.   }elseif($gpid > 0){ 
22.    //第一个子进程code，即孙进程的父进程 
23.    $status = 0; 
24.    $status = pcntl_wait($status); //阻塞子进程,并返回孙进程的退出状态，用于检查是否正常退出 
25.    if($status ! = 0) file_put_content('filename', '孙进程异常退出'); 
26.    //得到父进程id 
27.    //$ppid = posix_getppid(); //如果$ppid为1则表示其父进程已变为init进程，原父进程已退出 
28.    //得到子进程id：posix_getpid()或getmypid()或是fork返回的变量$pid 
29.    //kill掉子进程 
30.    //posix_kill(getmypid(), SIGTERM); 
31.    exit(0); 
32.   }else{ //即$gpid == 0 
33.    //孙进程code 
34.    //.... 
35.    //结束孙进程(即当前进程)，以防止生成僵尸进程 
36.    if(function_exists('posix_kill')){ 
37.      posix_kill(getmypid(), SIGTERM); 
38.    }else{ 
39.      system('kill -9'. getmypid()); 
40.    } 
41.    exit(0); 
42.   } 
43.  } 
44. } 
45. }else{ 
46.  // 不支持多进程处理时的代码在这里 
47. } 
48. //..... 
49. ?> 

怎样产生僵尸进程的

一个进程在调用exit命令结束自己的生命的时候，其实它并没有真正的被销毁，而是留下一个称为僵尸进程（Zombie）的数据结构（系统调用exit，它的作用是使进程退出，但也仅仅限于将一个正常的进程变成一个僵尸进程，并不能将其完全销毁）。在Linux进程的状态中，僵尸进程是非常特殊的一种，它已经放弃了几乎所有内存空间，没有任何可执行代码，也不能被调度，仅仅在进程列表中保留一个位置，记载该进程的退出状态等信息供其他进程收集，除此之外，僵尸进程不再占有任何内存空间。它需要它的父进程来为它收尸，如果他的父进程没安装SIGCHLD信号处理函数调用wait或waitpid()等待子进程结束，又没有显式忽略该信号，那么它就一直保持僵尸状态，如果这时父进程结束了，那么init进程自动会接手这个子进程，为它收尸，它还是能被清除的。但是如果如果父进程是一个循环，不会结束，那么子进程就会一直保持僵尸状态，这就是为什么系统中有时会有很多的僵尸进程。

任何一个子进程(init除外)在exit()之后，并非马上就消失掉，而是留下一个称为僵尸进程(Zombie)的数据结构，等待父进程处理。这是每个子进程在结束时都要经过的阶段。如果子进程在exit()之后，父进程没有来得及处理，这时用ps命令就能看到子进程的状态是”Z”。如果父进程能及时 处理，可能用ps命令就来不及看到子进程的僵尸状态，但这并不等于子进程不经过僵尸状态。

如果父进程在子进程结束之前退出，则子进程将由init接管。init将会以父进程的身份对僵尸状态的子进程进行处理。

另外，还可以写一个php文件，然后在以后台形式来运行它，例如：

1. <?php 
2. //Action代码 
3. public function createAction(){ 
4.   //.... 
5.   //将args替换成要传给insertLargeData.php的参数，参数间用空格间隔 
6.   system('php -f insertLargeData.php ' . ' args ' . '&'); 
7.   $this->redirect('/'); 
8. } 
9. ?> 

然后在insertLargeData.php文件中做数据库操作。也可以用cronjob + php的方式实现大数据量的处理。

如果是在终端运行php命令，当终端关闭后，刚刚执行的命令也会被强制关闭，如果你想让其不受终端关闭的影响，可以使用nohup命令实现：

1. <?php 
2. //Action代码 
3. public function createAction(){ 
4.   //.... 
5.   //将args替换成要传给insertLargeData.php的参数，参数间用空格间隔 
6.   system('nohup php -f insertLargeData.php ' . ' args ' . '&'); 
7.   $this->redirect('/'); 
8. } 
9. ?> 

你还可以使用screen命令代替nohup命令。

Tags: PHP多进程编程

分享到：