Two common ways to implement daemon processes in PHP

This article mainly introduces two common implementation methods of PHP daemon process, and analyzes the principles, related implementation methods and operating precautions of PHP daemon process with specific examples. Friends in need can refer to the following

The examples in this article describe two common implementation methods of PHP daemons. Share it with everyone for your reference, the details are as follows:

The first way is to use nohup and & together.

Adding the ampersand after the command allows the started process to run in the background without occupying the console. The console can also run other commands. Here I use a while Infinite loop for demonstration, the code is as follows

<?php
while(true){
    echo time().PHP_EOL;
    sleep(3);
}

Use & method to start the process

[root@localhost php]# php deadloop.php &
[1] 3454
[root@localhost php]# ps aux | grep 3454
root   3454 0.0 0.8 284544 8452 pts/0  T  18:06  0:00 php deadloop.php
root   3456 0.0 0.0 103316  896 pts/0  S+  18:08  0:00 grep 3454
[1]+ Stopped         php deadloop.php
[root@localhost php]#

You can see The process does not occupy the console, and the console can also run other commands. At this time, we can also use the fg command to restore the process to the mode of normally occupying the console.

[root@localhost php]# fg
php deadloop.php
1470996682
1470996685
1470996688
1470996691

The above is a brief introduction to the & command

Let’s look at another command nohup

Add nohup before the command to start The process will ignore the Linux hang-up signal (SIGHUP), so under what circumstances will the SIGHUP signal under Linux be triggered? The following content is taken from Baidu Encyclopedia:

SIGHUP will be triggered in the following three situations Sent to the corresponding process:

1. When the terminal is closed, the signal is sent to the session first process and the process submitted as a job (that is, the process submitted with the & symbol)
2. session When the first process exits, this signal is sent to every process in the foreground process group in the session
3. If the parent process exits, the process group becomes an orphan process group, and there are processes in the process group that are stopped ( When a SIGSTOP or SIGTSTP signal is received), the signal will be sent to every process in the process group.

Combining 1 and 2, we know that no matter whether the process is started in & (job mode) or not, the SIGHUP signal will be received when closing the terminal. So how will the process handle the SIGHUP signal? See also excerpted from Baidu A sentence from Encyclopedia

The system's default processing of the SIGHUP signal is to terminate the process that receives the signal. Therefore, if the signal is not captured in the program, the process will exit when the signal is received.

That is to say, closing the terminal process will receive the SIGHUP signal, and the default processing method of this signal is to end the process. Of course, we can also handle the signal ourselves, or ignore it, which is also an example of the above loop. , let’s make a slight improvement

<?php
declare(ticks = 1);
pcntl_signal(SIGHUP, function(){
    // 这地方处理信号的方式我们只是简单的写入一句日志到文件中
    file_put_contents(&#39;logs.txt&#39;, &#39;pid : &#39; . posix_getpid() . &#39; receive SIGHUP 信号&#39; . PHP_EOL);
});
while(true){
    echo time().PHP_EOL;
    sleep(3);
}

We don’t have to be so troublesome, we just need to use the nohup command provided by linux, but when we use nohup to start the process, close the terminal, The process will ignore the SIGHUP signal and will not exit. First, remove the signal processing code just now. Then run nohup.

[root@localhost php]# nohup php deadloop.php

nohup: Ignore input and append output to "nohup.out"

And nohup will redirect the program's output to the current directory by default nohup.out file, if there is no writable permission, write $homepath/nohup.out

[root@localhost php]# ls
cmd.sh deadloop.php getPhoto.php nohup.out pics
[root@localhost php]# tail -f nohup.out
1470999772
1470999775
1470999778
1470999781
1470999784
1470999787
1470999790
1470999793
1470999796
1470999799
1470999802

At this time, close the terminal, the process will not end, but will change It became an orphan process (ppid=1) because the parent process that created it exited.

[root@localhost ~]# ps -ef | grep 3554
root   3554 3497 0 19:09 pts/0  00:00:00 php deadloop.php
root   3575 3557 0 19:10 pts/1  00:00:00 grep 3554
[root@localhost ~]# ps -ef | grep 3554
root   3554   1 0 19:09 ?    00:00:00 php deadloop.php
root   3577 3557 0 19:10 pts/1  00:00:00 grep 3554
[root@localhost ~]#

Conclusion: So when we combine the nohup and & methods, the started process will not occupy the console nor rely on the console , after the console is closed, the process is adopted by process No. 1 and becomes an orphan process. This is very similar to the mechanism of a daemon process.

[root@localhost php]# nohup php deadloop.php >logs.txt 2>error.txt &
[1] 3612
[root@localhost php]# ps -ef |grep 3612
root   3612 3557 0 19:18 pts/1  00:00:00 php deadloop.php
root   3617 3557 0 19:19 pts/1  00:00:00 grep 3612
[root@localhost php]#

Among them >logs.txt redirects standard output, 2>error.txt redirects standard error output.

The above is an introduction to the first implementation method.

The second implementation method is to implement it through code according to the rules and characteristics of the daemon process,The biggest feature of the daemon process is that it is separated from the user terminal and Session , the following is the implemented code, and the key places are commented.

<?php
$pid = pcntl_fork();
if ($pid == -1)
{
  throw new Exception(&#39;fork子进程失败&#39;);
}
elseif ($pid > 0)
{
  //父进程退出,子进程变成孤儿进程被1号进程收养，进程脱离终端
  exit(0);
}
// 最重要的一步，让该进程脱离之前的会话，终端，进程组的控制
posix_setsid();
// 修改当前进程的工作目录，由于子进程会继承父进程的工作目录，修改工作目录以释放对父进程工作目录的占用。
chdir(&#39;/&#39;);
/*
 * 通过上一步，我们创建了一个新的会话组长，进程组长，且脱离了终端，但是会话组长可以申请重新打开一个终端，为了避免
 * 这种情况，我们再次创建一个子进程，并退出当前进程，这样运行的进程就不再是会话组长。
 */
$pid = pcntl_fork();
if ($pid == -1)
{
  throw new Exception(&#39;fork子进程失败&#39;);
}
elseif ($pid > 0)
{
  // 再一次退出父进程，子进程成为最终的守护进程
  exit(0);
}
// 由于守护进程用不到标准输入输出，关闭标准输入，输出，错误输出描述符
fclose(STDIN);
fclose(STDOUT);
fclose(STDERR);
/*
 * 处理业务代码
 */
while(TRUE)
{
  file_put_contents(&#39;log.txt&#39;, time().PHP_EOL, FILE_APPEND);
  sleep(5);
}

That's all!

The above is the detailed content of Two common ways to implement daemon processes in PHP. For more information, please follow other related articles on the PHP Chinese website!