PHP多进程任务学习实践

直接上代码

ini_set('display_errors', 'off');
error_reporting(E_ALL^E_WARNING^E_NOTICE);

// 作用是每执行一次低级语句会检查一次该进程是否有未处理过的信号，ticks控制语句执行的条数
declare(ticks = 1);

class JobDaemonDemo
{
    public $maxProcess = 5; // 设置最大进程数
    protected $currentJobs = []; // 记录当前执行的任务列表
    protected $parentPID;

    public function __construct()
    {
        echo "任务初始化...", PHP_EOL;
        $this->parentPID = getmypid();
        /**
         * pcntl_signal 注册 sigHandler 信号处理回调函数
         */
        pcntl_signal(SIGCHLD, [$this, "sigHandler"]); // handle shutdown tasks
        pcntl_signal(SIGHUP, [$this, "sigHandler"]); // handle restart tasks
        pcntl_signal(SIGUSR1, [$this, "sigHandler"]); // handle custom tasks
    }

    public function run()
    {
        echo "任务启动中...", PHP_EOL;
        @cli_set_process_title("job-daemon"); // 设置主进程别名为 job-daemon
        /** @var Redis $redis */
        $redis = require "./redis.php"; // redis.php 返回一个redis的连接
        while (true) {
            $jobLen = $redis->lLen("mylist");
            // 同时存在 $this->maxProcess 个任务进程
            if ($jobLen > 0 && sizeof($this->currentJobs) < $this->maxProcess) {
                $job = $redis->lPop("mylist");
                // 主进程分配任务
                $this->launchJob($job);
            }
        }
    }

    /**
     * 代码执行逻辑：
     *  $pid = pcntl_fork() 方法会fork出一个子进程，返回pid，然后代码继续顺序执行
     *  $pid = -1，表示fork进程失败
     *  $pid > 0，表示fork进程成功，返回子进程的pid，这一段可以执行主进程的业务逻辑
     *  $pid = 0，表示这段代码是在子进程中执行的，这一段可以执行子进程的业务逻辑
     *
     * @param $job
     * @return bool
     */
    protected function launchJob($job)
    {
        $pid = pcntl_fork();
        if ($pid < 0) {
            error_log('不能执行任务!');
            return false;
        } elseif ($pid === 0) {
            // Forked child, do your deeds....
            @cli_set_process_title("job-worker"); // 设置子进程的别名为 job-worker
            sleep(rand(10, 30 * 3));
            echo "在子进程中做一些酷酷的事情，".getmypid()."\n\n\n";
            echo $job, PHP_EOL;
            exit(0);
        } else {
            // Parent process，存储分配的任务
            echo "add ${pid} to current jobs: ${job} \n";
            $this->currentJobs[$pid] = $job;
        }
    }

    public function sigHandler($signo, $pid = null, $status = null)
    {
        /**
         * sigHandler输出内容示例
         * 
         * pcntl_waitpid 返回进程pid
         */
        echo ">>>> pid out while: \n";
        print_r($pid);
        while (($pid = pcntl_waitpid(-1, $status, WNOHANG)) > 0) {
            if (pcntl_wifsignaled($status)) {
                /**
                 * sigHandler输出内容示例，接收到了终止任务的信号
                 *
                 * kill -9 $pid 执行了手动终止进程，将会执行这段代码，并终止未完成的任务
                 * >>>> pid out while:
                 *   Array
                 *   (
                 *       [signo] => 17
                 *       [errno] => 0
                 *       [code] => 2
                 *       [status] => 9
                 *       [utime] => 0
                 *       [stime] => 0
                 *       [pid] => 5148
                 *       [uid] => 0
                 *       )
                 *   child 5148 cancel signal 9
                 *   pid inner while: 5148, status: 9
                 *   -----------------------
                 */
                printf("child %d cancel signal %d \n", $pid, $status);
            } elseif (pcntl_wifexited($status)) {
                /**
                 * sigHandler输出内容示例
                 * 子进程正常退出正常退出将会运行这段代码，比如任务完成，正常退出进程 exit(0)
                 * 
                 * echo ">>>> pid out while: \n";
                 * print_r($pid);
                 * >>>> pid out while:
                 *   Array
                 *   (
                 *       [signo] => 17
                 *       [errno] => 0
                 *       [code] => 2
                 *       [status] => 9
                 *       [utime] => 0
                 *       [stime] => 0
                 *       [pid] => 5131
                 *       [uid] => 0
                 *   )
                 *   pid inner while: 5131, status: 9
                 *   -----------------------
                 */
                printf(">>> child %d exit %d\n", $pid, $status);
            }
            echo "pid inner while: $pid, status: $status \n";
            if (isset($this->currentJobs[$pid])) {
                unset($this->currentJobs[$pid]);
            }
            echo "-----------------------\n";
        }
    }
}

(new JobDaemonDemo())->run();

扩展学习

在测试多进程任务的时候，ps -ef 查看进程，发现了如下输出：

root@4efff09cfb9e:/# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 Dec12 ?        00:00:00 php -a
root         6     0  0 Dec12 ?        00:00:00 /bin/bash
root      4878     0 11 Dec16 ?        02:12:47 redis-server *:6379
root      5032     0  0 02:49 ?        00:00:00 /bin/bash
root      5052     0  0 02:50 ?        00:00:00 /bin/bash
root      5080  5032 60 03:13 ?        00:00:27 job-daemon
root      5082  5080  0 03:13 ?        00:00:00 [php] <defunct>
root      5083  5080  0 03:13 ?        00:00:00 [php] <defunct>
root      5084  5080  0 03:13 ?        00:00:00 [php] <defunct>
root      5085  5080  0 03:13 ?        00:00:00 [php] <defunct>
root      5087  5052  0 03:14 ?        00:00:00 ps -ef

即 [php] <defunct> 未知进程描述，查询了下，这个是僵尸进程的描述信息，于是就扩展学习了下什么是僵尸进程。

下面的内容摘自杀死Linux中的defunct进程(僵尸进程)的方法指南，感兴趣的同学可以点击连接查看原文。

什么是defunct进程（僵尸进程）

在 Linux 系统中，一个进程结束了，但是他的父进程没有等待(调用wait / waitpid)他，那么他将变成一个僵尸进程。当用ps命令观察进程的执行状态时，看到这些进程的状态栏为defunct。僵尸进程是一个早已死亡的进程，但在进程表（processs table）中仍占了一个位置（slot）。

但是如果该进程的父进程已经先结束了，那么该进程就不会变成僵尸进程。因为每个进程结束的时候,系统都会扫描当前系统中所运行的所有进程，看看有没有哪个进程是刚刚结束的这个进程的子进程，如果是的话，就由Init进程来接管他，成为他的父进程，从而保证每个进程都会有一个父进程。而Init进程会自动wait其子进程,因此被Init接管的所有进程都不会变成僵尸进程。

Linux下进程的运作方式

每个 Linux进程在进程表里都有一个进入点（entry），核心进程执行该进程时使用到的一切信息都存储在进入点。当用 ps 命令察看系统中的进程信息时，看到的就是进程表中的相关数据。当以fork()系统调用建立一个新的进程后，核心进程就会在进程表中给这个新进程分配一个进入点，然后将相关信息存储在该进入点所对应的进程表内。这些信息中有一项是其父进程的识别码。
子进程的结束和父进程的运行是一个异步过程，即父进程永远无法预测子进程到底什么时候结束。那么会不会因为父进程太忙来不及 wait 子进程，或者说不知道子进程什么时候结束，而丢失子进程结束时的状态信息呢？
不会。因为 Linux提供了一种机制可以保证，只要父进程想知道子进程结束时的状态信息，就可以得到。这种机制就是：当子进程走完了自己的生命周期后，它会执行exit()系统调用，内核释放该进程所有的资源，包括打开的文件，占用的内存等。但是仍然为其保留一定的信息（包括进程号the process ID，退出码exit code，退出状态the terminationstatus of the process，运行时间the amount of CPU time taken by the process等），这些数据会一直保留到系统将它传递给它的父进程为止，直到父进程通过wait / waitpid来取时才释放。
也就是说，当一个进程死亡时，它并不是完全的消失了。进程终止，它不再运行，但是还有一些残留的数据等待父进程收回。当父进程 fork() 一个子进程后，它必须用 wait() （或者 waitpid()）等待子进程退出。正是这个 wait() 动作来让子进程的残留数据消失。

僵尸进程的危害

如果父进程不调用wait / waitpid的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统的进程表容量是有限的，所能使用的进程号也是有限的，如果大量的产生僵尸进程,将因为没有可用的进程号而导致系统不能产生新的进程。
所以，defunct进程不仅占用系统的内存资源，影响系统的性能，而且如果其数目太多，还会导致系统瘫痪。而且，由于调度程序无法选中Defunct 进程，所以不能用kill命令删除Defunct 进程，惟一的方法只有重启系统。

如何杀死defunct进程

defunct进程是指出错损坏的进程，父子进程之间不会再通信。有时，它们会演变成“僵尸进程”，存留在你的系统中，直到系统重启。可以尝试 “kill -9” 命令来清除，但多数时候不管用。
为了杀死这些defunct进程，你有两个选择：
1、重启你的计算机
2、kill掉父进程