澳门新葡萄京娱乐场深入探究PHP的多进程编程方法

子进程的创建一般的子进程的写法是:

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

php$pid = pcntl_fork();if($pid == -1){ //创建失败 die('could not fork');}else{ if($pid){ //从这里开始写的代码是父进程的 exit("parent!"); } else{ //子进程代码,为防止不停的启用子进程造成系统资源被耗尽的情况,一般子进程代码运行完成后,加入exit来确保子进程正常退出。 exit("child"); }}

常用的PCNTL函数

上边的代码如果创建子进程成功的话,系统就有了2个进程,一个为父进程,一个为子进程,子进程的id号为$pid。在系统运行到$pid

pcntl_fork();时,在这个地方进行分支,父子进程各自开始运行各自的程序代码。代码的运行结果是parent
和child,很奇怪吧,为什么一个if和else互斥的代码中,都输出了结果?其实是像上边所说的,代码在pcntl_fork时,一个父进程运行parent,一个子进程运行了child。在代码结果上就显示了parent和child。至于谁先谁后的问题,这得要看系统资源的分配了。

如果需要起多个进程来处理数据,可以根据数据的数量,按照约定好的数量比如说1000条一个进程来起子进程。使用for循环就可以了。

 #如果获得的总数小于或等于0,等待60秒,并退出 if ($count = 0) { sleep(60); exit; } #如果大于1000,计算需要起的进程数 if ($count  1000) { $cycleSize = ceil($count/1000); } else { $cycleSize = 1; } for ($i=0; $i$cycleSize; $i++) { $pid = pcntl_fork(); if($pid == -1) { break; } else { if($pid) { #父进程获得子进程的pid,存入数组 $pidArr[] = $pid; } else { //开始发送,子进程执行完自己的任务后,退出。 exit; } } } while(count($pidArr)  0) { $myId = pcntl_waitpid(-1, $status, WNOHANG); foreach($pidArr as $key = $pid) { if($myId == $pid) unset($pidArr[$key]); } }

然后使用crontab,来使此PHP程序每隔一段时间自动执行。

当然,示例代码比较简单,具体还需要考虑怎么防止多个子进程执行到同一条数据或者当前进程处理数据未完成时,crontab又开始执行PHP文件启用新的进程等等。

PHP多进程实现方式下面来系统地整理一下PHP多进程的实现方式:

1. 直接方式

pcntl_fork()
创建一个进程,在父进程返回值是子进程的pid,在子进程返回值是0,-1表示创建进程失败。跟C非常相似。

测试脚本 test.php

php // example of multiple processes date_default_timezone_set( 'Asia/Chongqing'); echo "parent start, pid ", getmypid(), "/n" ; beep(); for ($i=0; $i3; ++$i){ $pid = pcntl_fork(); if ($pid == -1){ die ("cannot fork" ); } else if ($pid  0){ echo "parent continue /n"; for ($k=0; $k2; ++$k){ beep(); } } else if ($pid == 0){ echo "child start, pid ", getmypid(), "/n" ; for ($j=0; $j5; ++$j){ beep(); } exit ; } } // *** function beep(){ echo getmypid(), "/t" , date( 'Y-m-d H:i:s', time()), "/n" ; sleep(1); }

用命令行运行

#php -f test.php

输出结果

parent start, pid 17931793 2013-01-14 15:04:17parent continue1793 2013-01-14 15:04:18child start, pid 17941794 2013-01-14 15:04:181794 2013-01-14 15:04:191793 2013-01-14 15:04:191794 2013-01-14 15:04:20parent continue1793 2013-01-14 15:04:20child start, pid 17951795 2013-01-14 15:04:2017931794 2013-01-14 15:04:212013-01-14 15:04:211795 2013-01-14 15:04:211794 2013-01-14 15:04:221795 2013-01-14 15:04:22parent continue1793 2013-01-14 15:04:22child start, pid 17961796 2013-01-14 15:04:221793 2013-01-14 15:04:231796 2013-01-14 15:04:231795 2013-01-14 15:04:231795 2013-01-14 15:04:241796 2013-01-14 15:04:241796 2013-01-14 15:04:251796 2013-01-14 15:04:26

从中看到,创建了3个子进程,和父进程一起并行运行。其中有一行格式跟其他有些不同,17931794
2013-01-14 15:04:212013-01-14
15:04:21因为两个进程同时进行写操作,造成了冲突。

2. 阻塞方式

用直接方式,父进程创建了子进程后,并没有等待子进程结束,而是继续运行。似乎这里看不到有什么问题。如果php脚本并不是运行完后自动结束,而是常驻内存的,就会造成子进程无法回收的问题。也就是僵尸进程。可以通过pcntl_wai()方法等待进程结束,然后回收已经结束的进程。将测试脚本改成:

$pid = pcntl_fork();if ($pid == -1){ ...} else if ($pid  0){ echo "parent continue /n"; pcntl_wait($status); for ($k=0; $k2; ++$k){ beep(); }} else if ($pid == 0){ ...}

用命令行运行

#php -f test.php

输出结果

parent start, pid 18071807 2013-01-14 15:20:05parent continuechild start, pid 18081808 2013-01-14 15:20:061808 2013-01-14 15:20:071808 2013-01-14 15:20:081808 2013-01-14 15:20:091808 2013-01-14 15:20:101807 2013-01-14 15:20:111807 2013-01-14 15:20:12parent continuechild start, pid 18091809 2013-01-14 15:20:131809 2013-01-14 15:20:141809 2013-01-14 15:20:151809 2013-01-14 15:20:161809 2013-01-14 15:20:171807 2013-01-14 15:20:181807 2013-01-14 15:20:19child start, pid 18101810 2013-01-14 15:20:20parent continue1810 2013-01-14 15:20:211810 2013-01-14 15:20:221810 2013-01-14 15:20:231810 2013-01-14 15:20:241807 2013-01-14 15:20:251807 2013-01-14 15:20:26

父进程在pcntl_wait()将自己阻塞,等待子进程运行完了才接着运行。

3. 非阻塞方式

阻塞方式失去了多进程的并行性。还有一种方法,既可以回收已经结束的子进程,又可以并行。这就是非阻塞的方式。修改脚本:

php // example of multiple processes date_default_timezone_set( 'Asia/Chongqing'); declare (ticks = 1); pcntl_signal(SIGCHLD, "garbage" ); echo "parent start, pid ", getmypid(), "/n" ; beep(); for ($i=0; $i3; ++$i){ $pid = pcntl_fork(); if ($pid == -1){ die ("cannot fork" ); } else if ($pid  0){ echo "parent continue /n"; for ($k=0; $k2; ++$k){ beep(); } } else if ($pid == 0){ echo "child start, pid ", getmypid(), "/n" ; for ($j=0; $j5; ++$j){ beep(); } exit (0); } } // parent while (1){ // do something else sleep(5); } // *** function garbage($signal){ echo "signel $signal received/n" ; while (($pid = pcntl_waitpid(-1, $status, WNOHANG)) 0){ echo "/t child end pid $pid , status $status/n" ; } } function beep(){ echo getmypid(), "/t" , date( 'Y-m-d H:i:s', time()), "/n" ; sleep(1); }

用命令行运行

#php -f test.php &

输出结果

parent start, pid 20662066 2013-01-14 16:45:34parent continue2066 2013-01-14 16:45:35child start, pid 20672067 2013-01-14 16:45:3520662067 2013-01-14 16:45:362013-01-14 16:45:362067 2013-01-14 16:45:37parent continue2066 2013-01-14 16:45:37child start, pid 20682068 2013-01-14 16:45:372067 2013-01-14 16:45:382068 2013-01-14 16:45:382066 2013-01-14 16:45:38parent continue2066 2013-01-14 16:45:40child start, pid 20692069 2067 2013-01-14 16:45:402013-01-14 16:45:402068 2013-01-14 16:45:402066 2013-01-14 16:45:412069 2013-01-14 16:45:412068 2013-01-14 16:45:41signel 17 received child end pid 2067, status 02069 2013-01-14 16:45:422068 2013-01-14 16:45:422069 2013-01-14 16:45:43signel 17 received child end pid 2068, status 02069 2013-01-14 16:45:44signel 17 received child end pid 2069, status 0

多个进程又并行运行了,而且运行大约10秒钟之后,用 ps -ef | grep php
查看正在运行的进程,只有一个进程lqling 2066 1388 0 16:45 pts/1 00:00:00
php -f t5.php是父进程,子进程被回收了。

子进程退出状态

pcntl_waitpid(-1, $status, WNOHANG) $status

返回子进程的结束状态

windows下多线程

windows系统不支持pcntl函数,幸好有curl_multi_exec()这个工具,利用内部的多线程,访问多个链接,每个链接可以作为一个任务。

编写脚本 test1.php

php date_default_timezone_set( 'Asia/Chongqing'); $tasks = array( '', '', '' ); $mh = curl_multi_init(); foreach ($tasks as $i = $task){ $ch[$i] = curl_init(); curl_setopt($ch[$i], CURLOPT_URL, $task); curl_setopt($ch[$i], CURLOPT_RETURNTRANSFER, 1); curl_multi_add_handle($mh, $ch[$i]); } do {$mrc = curl_multi_exec($mh,$active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); while ($active && $mrc == CURLM_OK) { if (curl_multi_select($mh) != -1) { do {$mrc = curl_multi_exec($mh, $active); } while ($mrc == CURLM_CALL_MULTI_PERFORM); } } // completed, checkout result foreach ($tasks as $j = $task){ if (curl_error($ch[$j])){ echo "task ${j} [$task ] error " , curl_error($ch[$j]), "/r/n" ; } else { echo "task ${j} [$task ] get: /r/n" , curl_multi_getcontent($ch[$j]), "/r/n" ; } }

编写脚本 test2.php

php date_default_timezone_set( 'Asia/Chongqing'); echo "child start, pid ", getmypid(), "/r/n" ; for ($i=0; $i5; ++$i){ beep(); } exit (0); // *** function beep(){ echo getmypid(), "/t" , date('Y-m-d H:i:s' , time()), "/r/n"; sleep(1); }

用命令行运行

#php -f test1.php &

输出结果

task 0 [] get:child start, pid 58045804 2013-01-15 20:22:355804 2013-01-15 20:22:365804 2013-01-15 20:22:375804 2013-01-15 20:22:385804 2013-01-15 20:22:39task 1 [] get:child start, pid 58045804 2013-01-15 20:22:355804 2013-01-15 20:22:365804 2013-01-15 20:22:375804 2013-01-15 20:22:385804 2013-01-15 20:22:39task 2 [] get:child start, pid 58045804 2013-01-15 20:22:355804 2013-01-15 20:22:365804 2013-01-15 20:22:375804 2013-01-15 20:22:385804 2013-01-15 20:22:39

从打印的时间看到,多个任务几乎是同时运行的。

   1. pcntl_alarm ( int $seconds )

      设置一个$seconds秒后发送SIGALRM信号的计数器
   2. pcntl_signal ( int $signo , callback $handler [, bool
$restart_syscalls ] )

     
为$signo设置一个处理该信号的回调函数。下面是一个隔5秒发送一个SIGALRM信号,并由signal_handler函数获取,然后打印一个“Caught
SIGALRM”的例子:
declare(ticks = 1);

function signal_handler($signal) {
print “Caught SIGALRMn”;
pcntl_alarm(5);
}

pcntl_signal(SIGALRM, “signal_handler”, true);
pcntl_alarm(5);

for(;;) {
}

?>

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

     
在当前的进程空间中执行指定程序,类似于c中的exec族函数。所谓当前空间,即载入指定程序的代码覆盖掉当前进程的空间,执行完该程序进程即结束。
$dir = ‘/home/shankka/’;
$cmd = ‘ls’;
$option = ‘-l’;
$pathtobin = ‘/bin/ls’;

$arg = array($cmd, $option, $dir);

pcntl_exec($pathtobin, $arg);
echo ‘123’; //不会执行到该行
?>

   4. pcntl_fork ( void )

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

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

      注意两点:
      1. 子进程最好有一个exit;语句,防止不必要的出错;
      2. pcntl_fork间最好不要有其它语句,例如:
$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
}

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

     
阻塞当前进程,只到当前进程的一个子进程退出或者收到一个结束当前进程的信号。使用$status返回子进程的状态码,并可以指定第二个参数来说明是否以阻塞状态调用:
      1.
阻塞方式调用的,函数返回值为子进程的pid,如果没有子进程返回值为-1;
      2.
非阻塞方式调用,函数还可以在有子进程在运行但没有结束的子进程时返回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这些函数。

      例如:

       $pid = pcntl_fork();
if($pid) {
pcntl_wait($status);
$id = getmypid();
echo “parent process,pid {$id}, child pid {$pid}n”;
}else{
$id = getmypid();
echo “child process,pid {$id}n”;
sleep(2);
}
?>

      子进程在输出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

      用来设置信号的回调函数

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

   1.
当父进程退出时,会有一个INIT进程来领养这个子进程。这个INIT进程的进程号为1,所以子进程可以通过使用getppid()来取得当前父进程的pid。如果返回的是1,表明父进程已经变为INIT进程,则原进程已经推出。
   2. 使用kill函数,向原有的父进程发送空信号(kill(pid,
0))。使用这个方法对某个进程的存在性进行检查,而不会真的发送信号。所以,如果这个函数返回-1表示父进程已经退出。

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

PHP多进程采集数据的例子

/**
* Project: Signfork: php多线程库
* File: Signfork.class.php
*/

class Signfork{
/**
* 设置子进程通信文件所在目录
* @var string
*/
private $tmp_path=’/tmp/’;

/**
* Signfork引擎主启动方法
*
1、判断$arg类型,类型为数组时将值传递给每个子进程;类型为数值型时,代表要创建的进程数.
* @param object $obj 执行对象
* @param string|array $arg 用于对象中的__fork方法所执行的参数
*
如:$arg,自动分解为:$obj->__fork($arg[0])、$obj->__fork($arg[1])…
* @return array 返回 array(子进程序列=>子进程执行结果);
*/
public function run($obj,$arg=1){
if(!method_exists($obj,’__fork’)){
exit(“Method ‘__fork’ not found!”);
}

if(is_array($arg)){
$i=0;
foreach($arg as
$key=>$val){
$spawns[$i]=$key;
$i++;
$this->spawn($obj,$key,$val);
}
$spawns[‘total’]=$i;
}elseif($spawns=intval($arg)){
for($i = 0; $i < $spawns; $i++){
$this->spawn($obj,$i);
}
}else{
exit(‘Bad argument!’);
}

if($i>1000) exit(‘Too many spawns!’);
return
$this->request($spawns);
}

/**
* Signfork主进程控制方法
* 1、$tmpfile
判断子进程文件是否存在,存在则子进程执行完毕,并读取内容
* 2、$data收集子进程运行结果及数据,并用于最终返回
* 3、删除子进程文件
* 4、轮询一次0.03秒,直到所有子进程执行完毕,清理子进程资源
* @param string|array $arg 用于对应每个子进程的ID
* @return array 返回 array([子进程序列]=>[子进程执行结果]);
*/
private function request($spawns){
$data=array();
$i=is_array($spawns)?$spawns[‘total’]:$spawns;
for($ids = 0; $ids<$i; $ids++){
while(!($cid=pcntl_waitpid(-1, $status, WNOHANG)))usleep(30000);
$tmpfile=$this->tmp_path.’sfpid_’.$cid;
$data[$spawns[‘total’]?$spawns[$ids]:$ids]=file_get_contents($tmpfile);
unlink($tmpfile);
}
return $data;
}

/**
* Signfork子进程执行方法
* 1、pcntl_fork 生成子进程
* 2、file_put_contents
将’$obj->__fork($val)’的执行结果存入特定序列命名的文本
* 3、posix_kill杀死当前进程
* @param object $obj 待执行的对象
* @param object $i 子进程的序列ID,以便于返回对应每个子进程数据
* @param object $param 用于输入对象$obj方法’__fork’执行参数
*/
private function spawn($obj,$i,$param=null){
if(pcntl_fork()===0){
$cid=getmypid();
file_put_contents($this->tmp_path.’sfpid_’.$cid,$obj->__fork($param));
posix_kill($cid, SIGTERM);
exit;
}
}
}
?>

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

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

PHP多进程编程示例2

//…..
//需要安装pcntl的php扩展,并加载它
if(function_exists(“pcntl_fork”)){
//生成子进程
$pid = pcntl_fork();
if($pid == -1){
die(‘could not fork’);
}else{
if($pid){
$status = 0;
//阻塞父进程,直到子进程结束,不适合需要长时间运行的脚本,可使用pcntl_wait($status,
0)实现非阻塞式
pcntl_wait($status);
// parent proc code
exit;
}else{
// child proc code
//结束当前子进程,以防止生成僵尸进程
if(function_exists(“posix_kill”)){
posix_kill(getmypid(), SIGTERM);
}else{
system(‘kill -9’. getmypid());
}
exit;
}
}
}else{
// 不支持多进程处理时的代码在这里
}
//…..
?>

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

pcntl_wait($status, 1);
//或
pcntl_wait($status, WNOHANG);

在上面的代码中,如果父进程退出(使用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)通知内核,自己对子进程的结束不感兴趣,那么子进程结束后,内核会回收,并不再给父进程发送信号,例如:

pcntl_signal(SIGCHLD, SIG_IGN);
$pid = pcntl_fork();
//….code

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

#include “apue.h”
#include
int main(void){
pid_t pid;

if ((pid = fork()) < 0){
err_sys(“fork error”);
} else if (pid == 0){ /**//* first child */
if ((pid = fork()) < 0){
err_sys(“fork error”);
}elseif(pid > 0){
exit(0); /**//* parent from second fork == first child */
}

/**
* We’re the second child; our parent becomes init as soon
* as our real parent calls exit() in the statement above.
* Here’s where we’d continue executing, knowing that when
* we’re done, init will reap our status.
*/
sleep(2);
printf(“second child, parent pid = %d “, getppid());
exit(0);
}

if (waitpid(pid, NULL, 0) != pid) /**//* wait for first child */
err_sys(“waitpid error”);

/**
* We’re the parent (the original process); we continue executing,
* knowing that we’re not the parent of the second child.
*/
exit(0);
}

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

      所以,上面的示例可以改成:

       //…..
//需要安装pcntl的php扩展,并加载它
if(function_exists(“pcntl_fork”)){
//生成第一个子进程
$pid = pcntl_fork(); //$pid即所产生的子进程id
if($pid == -1){
//子进程fork失败
die(‘could not fork’);
}else{
if($pid){
//父进程code
sleep(5); //等待5秒
exit(0); //或$this->_redirect(‘/’);
}else{
//第一个子进程code
//产生孙进程
if(($gpid = pcntl_fork()) < 0){ ////$gpid即所产生的孙进程id
//孙进程产生失败
die(‘could not fork’);
}elseif($gpid > 0){
//第一个子进程code,即孙进程的父进程
$status = 0;
$status = pcntl_wait($status);
//阻塞子进程,并返回孙进程的退出状态,用于检查是否正常退出
if($status ! = 0) file_put_content(‘filename’, ‘孙进程异常退出’);
//得到父进程id
//$ppid = posix_getppid();
//如果$ppid为1则表示其父进程已变为init进程,原父进程已退出
//得到子进程id:posix_getpid()或getmypid()或是fork返回的变量$pid
//kill掉子进程
//posix_kill(getmypid(), SIGTERM);
exit(0);
}else{ //即$gpid == 0
//孙进程code
//….
//结束孙进程(即当前进程),以防止生成僵尸进程
if(function_exists(‘posix_kill’)){
posix_kill(getmypid(), SIGTERM);
}else{
system(‘kill -9’. getmypid());
}
exit(0);
}
}
}
}else{
// 不支持多进程处理时的代码在这里
}
//…..
?>

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

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

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

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

//Action代码
public function createAction(){
//….
//将args替换成要传给insertLargeData.php的参数,参数间用空格间隔
system(‘php -f insertLargeData.php ‘ . ‘ args ‘ . ‘&’);
$this->redirect(‘/’);
}
?>

然后在insertLargeData.php文件中做数据库操作。也可以用cronjob

  • php的方式实现大数据量的处理。

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

//Action代码
public function createAction(){
//….
//将args替换成要传给insertLargeData.php的参数,参数间用空格间隔
system(‘nohup php -f insertLargeData.php ‘ . ‘ args ‘ . ‘&’);
$this->redirect(‘/’);
}
?>

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

发表评论

电子邮件地址不会被公开。 必填项已用*标注