【多进程】如何使用PHP编写daemon process

PHP 5.3.3 不能使用端口重用

PHP Notice: Use of undefined constant SO_REUSEPORT - assumed 'SO_REUSEPORT' in /soft/b.php on line 96

注意：

　　 多进程实现只能在cli模式下，在web服务器环境下，会出现无法预期的结果,我测试

报错：Call to undefined function: pcntl_fork()

一个错误 pcntl_fork causing “errno=32 Broken pipe” #474 ，看https://github.com/phpredis/phpredis/issues/474

注意两点：如果是在循环中创建子进程,那么子进程中最后要exit,防止子进程进入循环。
子进程中的打开连接不能拷贝，使用的还是主进程的，需要用多例模式。

信号处理

declare(ticks = 1);
pcntl_signal(SIGINT, 'signalHandler');

比较好的做法是去掉ticks，转而使用pcntl_signal_dispatch，在代码循环中自行处理信号。

demo1：

<?php
function stopAll($sig){
echo "master caught a signal $sig" . PHP_EOL;
}

$pid = pcntl_fork();

if($pid > 0)
{
$master_id = posix_getpid();
echo "(parent) parent process {$master_id}, child process {$pid}" . PHP_EOL;
pcntl_signal(SIGINT, 'stopAll') ;
$epid = pcntl_wait($status, WUNTRACED);
echo "======================" . PHP_EOL;
pcntl_signal_dispatch();

if($epid > 0) echo "child process $epid exit" . PHP_EOL;
}
else
{
$master_id = posix_getppid();
$id = posix_getpid();
echo "(child) child process {$id}" . PHP_EOL;
sleep(3);
echo "send signal to master" . PHP_EOL;
posix_kill($master_id, SIGINT);
}

备注说明：

1. 请自行注释第15行代码进行DEMO调试。

2. pcntl_wait其实就是wait系统调用，是可以被信号打断的，当信号到来后pcntl_wait会立刻返回。同理，sleep也是系统调用，也可以被信号打断停止睡眠立刻返回。所以在调用pcntl_wait或者sleep之后，再调用pcntl_signal_dispatch函数，如果收到了信号，那么pcntl_signal_dispatch函数会立刻被执行。

3. 信号有个作用，会打断系统调用，让系统调用立刻返回，比如read、poll等都是系统调用。
sleep也是系统调用，所以即使是sleep(100)，当信号发生时sleep会立刻返回，实际不会sleep 100秒。while循环里利用系统调用等待信号是一个很常用的做法，例如主进程监控子进程退出事件可以用wait系统调用，下一句紧接着是pcntl_signal_dispatch，这样既可以监听到子进程退出，也可以监听到其它信号并及时处理。

4. 信号回调是不会自己自动执行的，要么主动声明declare(ticks=1)，要么主动调用pcntl_signal_dispatch检查信号以执行信号回调处理函数，推荐高性能pcntl_singal_dispatch。

5. pcntl_signal_dispatch函数的作用：检测信号队列里是否有信号发生，如果有，则执行进程绑定的信号处理回调函数。

pcntl_fork:

<?php
set_time_limit(0);

// 只允许在cli下面运行
if (php_sapi_name() != "cli"){
exit("只允许在cli下面运行\n");
}

//第一子进程，实现与父进程的脱离
$pid = pcntl_fork();
if ($pid == -1) {
exit("fork failed！\n");
}elseif($pid > 0) {
exit(0);//父进程退出
}

//子进程成为新的会话组长
posix_setsid();
//为禁止第一子进程打开控制终端，需要创建第二子进程，具体我也不清楚什么原理
$pid = pcntl_fork();
if ($pid == -1) {
exit("fork2 failed！\n");
}elseif($pid > 0) {
exit(0);
}

echo "进程id：".posix_getpid()."\n";
$open = true;
function sig_handler($signo)
{
global $open;
switch ($signo) {
//自定义信号SIGUSR1
case SIGUSR1:
echo "你好啊，我继续跑\n";
break;
case SIGTERM:
echo "等这次循环结束我就关闭\n";
$open = false;
break;
default:
# code...
break;
}
}

pcntl_signal(SIGUSR1,'sig_handler');
pcntl_signal(SIGTERM,'sig_handler');

//这行代码很重要，这样每执行一条低级语句就能检查信号，否则无限循环中无法检测到进程信号
declare(ticks=1);
while($open){
echo date('Y-m-d H:i:s')."\n";
sleep(1);
}
echo "我退出了88";
exit;

今天下午在segmentfault.com看到一个提问，提问标题是“PHP怎么做服务化”，其中问道php是不是只能以web方式调用。其实很多人对PHP的使用场景都有误解，认为php只能用于编写web脚本，实际上，从PHP4开始，php的使用场景早已不限于处理web请求。

从php的架构体系来说，php分为三个层次：sapi、php core和zend engine。php core本身和web没有任何耦合，php通过sapi与其它应用程序通信，例如mod_php就是为apache编写的sapi实现，同样，fpm是一个基于fastcgi协议的sapi实现，这些sapi都是与web server配合用于处理web请求的。但是也有许多sapi与web无关，例如cli sapi可以使得在命令行环境下直接执行php，embed sapi可以将php嵌入其它语言（如Lua）那样。这里我并不打算详细讨论php的架构体系和sapi的话题，只是说明从架构体系角度目前的php早已被设计为支持各种环境，而非为web独有。

除了架构体系的支持外，php丰富的扩展模块也为php在不同环境发挥作用提供了后盾，例如本文要提到的pcntl模块和posix模块配合可以实现基本的进程管理、信号处理等操作系统级别的功能，而sockets模块可以使php具有socket通信的能力。因此php完全可以用于编写类似于shell或perl常做的工具性脚本，甚至是具有server性质的daemon process。

为了展示php如何编写daemon server，我用php编写了一个简单的http server，这个server以daemon process的形式运行。当然，为了把重点放在如何使用php编写daemon，我没有为这个http server实现具体业务逻辑，但它可以监听指定端口，接受http请求并返回给客户端一条固定的文本，整个过程通过socket实现，全部由php编写而成。

代码实例

下面是这个程序的完整代码：

<?php
//Accpet the http client request and generate response content.

//As a demo, this function just send "PHP HTTP Server" to client.

function handle_http_request($address,$port)
{

$max_backlog= 16;

$res_content= "HTTP/1.1 200 OK
Content-Length: 15
Content-Type: text/plain; charset=UTF-8
PHP HTTP Server";

$res_len=strlen($res_content);
//Create, bind and listen to socket

if(($socket= socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) === FALSE)
{
echo"Create socket failed!\n";
exit;

}

if((socket_bind($socket,$address,$port)) === FALSE)
{
echo"Bind socket failed!\n";
exit;

}

if((socket_listen($socket,$max_backlog)) === FALSE)
{
echo"Listen to socket failed!\n";
exit;

}

//Loop

while(TRUE)
{
if(($accept_socket= socket_accept($socket)) === FALSE)
{
continue;
}
else
{
socket_write($accept_socket,$res_content,$res_len);
socket_close($accept_socket);
}

}

}
//Run as daemon process.
function run()
{
if(($pid1= pcntl_fork()) === 0)
//First child process
{

posix_setsid();//Set first child process as the session leader.

if(($pid2= pcntl_fork()) === 0)

//Second child process, which run as daemon.
{

//Replaced with your own domain or address.

handle_http_request('www.codinglabs.org', 9999);

}
else
{
//First child process exit;
exit;
}
}
else
{
//Wait for first child process exit;
pcntl_wait($status);

}
}

//Entry point.
run();
?>

这里我假设各位对Unix环境编程都比较了解，所以不做太多细节的解释，只梳理一下。简单来看，这个程序主要由两个部分组成，handle_http_request函数负责处理http请求，其编写方法与用C编写的tcp server类似：创建socket、绑定、监听，然后通过一个循环处理每个connect过来的客户端，一旦accept到一个连接，则输出固定的文本“PHP HTTP Server”（当然http头需要首先构建好），这里没有考虑多路复用和非阻塞等情况，而只是一个简单的同步阻塞tcp server。

run函数负责将整个程序变为daemon process，方法和Unix环境下C的方法很类似，通过两次fork，第一次fork后调用setsid将子进程1变为session leader，这样就可以让子进程2与其祖先detach，即使祖先进程结束了它也会继续运行（托孤给init进程）。相关细节我不再赘述，对Unix进程相关不熟悉的朋友可以参考《Advanced Programming in the UNIX Environment》一书。

注意，在这里pcntl_fork对应Unix中的fork，pcntl_wait对应wait，而posix_setsid对应setsid，更多函数可以参考PHP Manual中的pcntl和fork模块相关内容。

检验

下面在命令行下启动这个脚本：

php httpserver.php

用ps命令可以看到我们已经启动了一个daemon进程：





这里我绑定的是我博客的域名www.codinglabs.org，端口是9999，可以按需要进行修改。

下面我先用curl命令看下这个http server是否正常运行：





看来是没问题，再到浏览器中看一下：

结语

当然，这个程序算不上真正的http server，即使作为一个daemon process，也是不完善的，很多必要的事情如修改执行目录（php中可以通过chroot实现）、信号绑定、日志功能等等都没有去做，不过作为一个demo，它已经足够说明php不只是可以编写动态网页处理脚本。如果有的朋友有兴趣，可以使用php将我上面说的功能为这个的http server加上。

还有一点要说明的是，pcntl和sockets模块默认是不安装的，如果在安装php时没有通过参数指定安装，则需要单独安装这两个扩展模块。

多个进程监听同一个端口：

<?php

/**
* 入口函数
* 将此文件保存为 ProcessOpera.php
* 查看进程 ps aux|grep php
*/

$worker_num=2;

daemon();

ProcessOpera("runCode", array(), $worker_num);

$pids=array();

// 信号注册：当接收到SIGINT信号时，调用signalHandler()函数
pcntl_signal(SIGINT, 'signalHandler');
pcntl_signal(SIGCHLD, "signalHandler");// 注册子进程退出时调用的函数
pcntl_signal(SIGTERM, "signalHandler");// 注册子进程退出时调用的函数

// 定义一个处理器，接收到SIGINT信号后只输出一行信息
function signalHandler($signal) {
//print_r($pids);
switch($signal) {
case SIGCHLD:
echo 'SIGCHLD received'."n";
break;
case SIGINT:
echo 'signal received' . PHP_EOL;
break;
case SIGTERM:
echo 'SIGTERM received' . PHP_EOL;
break;
}
}

/**
* run Code
*/
function runCode($opt = array()) {

handle_http_request('127.0.0.1', 9999);
//需要在守护进程中运行的代码
}

while(1)
{
$status = 0;
$pid = pcntl_wait($status,WUNTRACED);
if($pid > 0)
{
echo "pid:$pid exit,status:$status";
}
}

/**
* $func为子进程执行具体事物的函数名称
* $opt为$func的参数 数组形式
* $pNum 为fork的子进程数量
*/
function ProcessOpera($func, $opts = array(), $pNum = 1) {
//while(true) {
for($i=0;$i<$pNum;$i++){
$pid = pcntl_fork();
if($pid == -1) {
exit("pid fork error");
}
if($pid) {
static $execute = 0;
$execute++;
$pids[]=$pid;
//            if($execute >= $pNum) {
//                pcntl_wait($status);
//                $execute--;
//            }
} else {
//调用已安装的信号信号处理器，为了检测是否有新的信号等待dispatching
pcntl_signal_dispatch();
echo "I am child: ".getmypid(). " and i am running !".PHP_EOL;
$func($opts);
//            while(true) {
//                //somecode
//                echo "I am child: ".getmypid(). " and i am running !".PHP_EOL;
//                $func($opts);
//                sleep(1);
//            }
//exit(0);
}
}
}

function handle_http_request($address, $port)
{
$max_backlog = 16;

$res_content = "HTTP/1.1 200 OK
Content-Length: 15
Content-Type: text/plain; charset=UTF-8

PHP HTTP Server";

$res_len = strlen($res_content);
// Create, bind and listen to socket
if (($socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) === false)
{
echo"Create socket failed!\n";
exit;
}
// 监听多端口
//socket_set_option($socket, SOL_SOCKET, SO_REUSEADDR, 1); //地址重用
socket_set_option($socket, SOL_SOCKET, SO_REUSEPORT, 1); //端口重用

if ((socket_bind($socket, $address, $port)) === false)
{
echo"Bind socket failed!\n";
exit;
}

if ((socket_listen($socket, $max_backlog)) === false)
{
echo"Listen to socket failed!\n";
exit;
}
// Loop
while (true)
{
if (($accept_socket = socket_accept($socket)) === false)
{
continue;
}
else
{
socket_write($accept_socket, $res_content, $res_len);
socket_close($accept_socket);
}
}
}

function daemon()
{
$pid = pcntl_fork();

if ($pid == -1)
{
exit(1);
}
elseif ($pid > 0)
{
exit(0);
}
else
{
posix_setsid();
umask(0);
chdir('./');
fclose(STDOUT);
fclose(STDERR);

$pid = pcntl_fork();

if ($pid == -1)
{
exit(1);
}
elseif ($pid > 0)
{
exit(0);
}
else
{
unset($pid);
}

}
}

PHP进程通信基础——信号

PHP进程通信基础——信号量+共享内存通信

开启pcntl_fork(开始php多线程)

PHP多进程编程

使用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”的例子：

<?php
declare(ticks = 1);

function signal_handler($signal) {
print "Caught SIGALRM\n";
pcntl_alarm(5);
}

pcntl_signal(SIGALRM, "signal_handler", true);
pcntl_alarm(5);

for(;;) {
}

?>

3. pcntl_exec ( string $path [, array $args [, array $envs ]] )
在当前的进程空间中执行指定程序，类似于c中的exec族函数。所谓当前空间，即载入指定程序的代码覆盖掉当前进程的空间，执行完该程序进程即结束。

<?php
$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间最好不要有其它语句，例如：

<?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
}
?>

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这些函数。
例如：

<?php
$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多进程采集数据的例子

<?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

<?php
//.....
//需要安装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)语句，或写成：

<?php
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)通知内核，自己对子进程的结束不感兴趣，那么子进程结束后，内核会回收，并不再给父进程发送信号，例如：

<?php
pcntl_signal(SIGCHLD, SIG_IGN);
$pid = pcntl_fork();
//....code
?>

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

#include "apue.h"
#include <sys/wait.h>

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回收清理这些父进程已退出的僵尸子进程。

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

<?php
//.....
//需要安装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文件，然后在以后台形式来运行它，例如：

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

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

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

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

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