A thorough understanding of PHP process signal processing in one article

Background

The boss arranged it for me two weeks ago I started a task and wrote a package that listens for signals. Because our company's projects run in containers, every time they go online, they need to repackage the image and then start it. Before repackaging, Dokcer will first send a signal to the container, then wait for a timeout period (default 10s), and then send the SIGKILL signal to terminate the container

Now there is a situation where there is a resident process in the container , the task of this resident process is to continuously consume messages in the queue. Suppose you want to go online now and you need to shut down the container. Docker sends a signal to the resident process running in the container, telling it that I will shut you down in 10 seconds. Suppose now 9 seconds have passed and the resident process has just been taken out of the queue. For a message, the process has been killed before the subsequent logic has been executed within 1 second. At this time, the message is lost, and dirty data may be generated.

The above is the background of this task. It needs to be Determine how to proceed by monitoring the signal. For the above situation, when the resident process receives the shutdown signal sent by Docker, the process can be blocked and sleep until the container is killed. OK, after clarifying the background, let’s introduce the signals in PHP (I will compile an article on how to write this package later, and publish the package to https://packagist.org/ for the use of friends who need it) [Recommended study ：PHP video tutorial】

1. What are the signals in the Linux operating system

1. Brief introduction to signals

#Signals are notification mechanisms for processes when events occur, sometimes also calledsoftware interrupts . A process can send a signal to another process. For example, when a child process ends, it will send a SIGCHLD (Signal No. 17) to the parent process to notify the parent process, so sometimes signals are also used as an inter-process communication mechanism.

In Linux systems, we usually use kill -9 XXPID to end a process. In fact, the essence of this command is to send SIGKILL (Signal No. 9) to a process. For processes in the foreground, we usually use Ctrl c shortcut key to end the run. The essence of this shortcut key is to send SIGINT (Signal No. 2) to the current process, and the default behavior of the process when receiving this signal is to end the run

2 , Commonly used signals

You can use the kill -l command to view the following signalsThe following introduces several important and commonly used signals:

2. Signal processing related functions in PHP

PHP’s pcntl extension and posix The extension provides us with several methods for operating signals (if you want to use these functions, you need to install these extensions first)

The following is a detailed introduction to several methods I used in this task:

declare

The declare structure is used to set the execution instructions for a piece of code. The syntax of declare is similar to other flow control structures

declare (directive)
    statement

The directive part allows you to set the behavior of the declare code segment. Currently, only two instructions are recognized: ticks and encoding. The statement part of the declare code section will be executed - how it is executed and what side effects occur depends on the instructions set in the directive

Ticks

Tick( Clock cycle) is an event that occurs every time the interpreter executes N timeable low-level statements in the declare code segment. The value of N is specified with ticks=N in the directive part of declare. Not all statements can be timed. Usually conditional expression and parameter expression are not timeable. The events that appear in each tick are specified by register_tick_function(). Note that multiple events can appear in each tick. For more detailed information, please view the official documentation: https://www.php.net/manual/zh/control-structures.declare.php

<?php
declare(ticks=1);//每执行一条时,触发register_tick_function()注册的函数
$a=1;//在注册之前,不算
function test(){//定义一个函数
    echo "执行\n";
}
register_tick_function(&#39;test&#39;);//该条注册函数会被当成低级语句被执行
for($i=0;$i<=2;$i++){//for算一条低级语句
    $i=$i;//赋值算一条
}
输出：六个“执行”

pcntl_signal

pcntl_signal, install a signal processor

pcntl_signal ( int $signo , callback $handler [, bool $restart_syscalls = true ] ) : bool

The function pcntl_signal() installs a new signal processor for the signal specified by signo

declare(ticks = 1);
pcntl_signal(SIGINT,function(){
    echo "你按了Ctrl+C".PHP_EOL;
});
while(1){
    sleep(1);//死循环运行低级语句
}
输出：当按Ctrl+C之后，会输出“你按了Ctrl+C”

posix_kill

posix_kill, sends a signal to the process

posix_kill ( int $pid , int $sig ) : bool

The first parameter is the process ID, the second parameter The parameter is the signal you want to send

a.php
<?php
declare(ticks = 1);
echo getmypid();//获取当前进程id
pcntl_signal(SIGINT,function(){
    echo "你给我发了SIGINT信号";
});
while(1){
    sleep(1);
}

b.php
<?php
posix_kill(执行1.php时输出的进程id, SIGINT);

##pcntl_signal_dispatch##pcntl_signal_dispatch, calling the processor waiting for the signal

pcntl_signal_dispatch ( void ) : bool

The function pcntl_signal_dispatch() calls each waiting signal through the processor installed by pcntl_signal()

<?php
echo "安装信号处理器...\n";
pcntl_signal(SIGHUP,  function($signo) {
     echo "信号处理器被调用\n";
});
echo "为自己生成SIGHUP信号...\n";
posix_kill(posix_getpid(), SIGHUP);
echo "分发...\n";
pcntl_signal_dispatch();
echo "完成\n";
?>

输出：
安装信号处理器...
为自己生成SIGHUP信号...
分发...
信号处理器被调用
完成

##pcntl_async_signals()Asynchronous signal processing is used to enable asynchronous signal processing without ticks (which will bring a lot of additional overhead). (PHP>=7.1)

<?php
pcntl_async_signals(true); // turn on async signals

pcntl_signal(SIGHUP,  function($sig) {
    echo "SIGHUP\n";
});

posix_kill(posix_getpid(), SIGHUP);

输出：
SIGHUP

Copy after login

3. The way to handle semaphores in PHPWe know what we know before You can monitor signals by combining declare(ticks=1) and pcntl_signal. That is, every low-level PHP statement will check whether there are unprocessed signals in the current process. This is actually very performance-consuming.

PHP_MINIT_FUNCTION(pcntl)
{
 php_register_signal_constants(INIT_FUNC_ARGS_PASSTHRU);
 php_pcntl_register_errno_constants(INIT_FUNC_ARGS_PASSTHRU);
 php_add_tick_function(pcntl_signal_dispatch TSRMLS_CC);

 return SUCCESS;
}

<?php
echo getmypid();//获取当前进程id
pcntl_signal(SIGUSR1,function(){
    echo "触发信号用户自定义信号1";
});
while(1){
    pcntl_signal_dispatch();
    sleep(1);//死循环运行低级语句
}

void pcntl_signal_dispatch()
{
 //.... 这里略去一部分代码，queue即是信号队列
 while (queue) {
  if ((handle = zend_hash_index_find(&PCNTL_G(php_signal_table), queue->signo)) != NULL) {
   ZVAL_NULL(&retval);
   ZVAL_LONG(&param, queue->signo);

   /* Call php signal handler - Note that we do not report errors, and we ignore the return value */
   /* FIXME: this is probably broken when multiple signals are handled in this while loop (retval) */
   call_user_function(EG(function_table), NULL, handle, &retval, 1, &param TSRMLS_CC);
   zval_ptr_dtor(&param);
   zval_ptr_dtor(&retval);
  }
  next = queue->next;
  queue->next = PCNTL_G(spares);
  PCNTL_G(spares) = queue;
  queue = next;
 }
}

<?php
//a.php
echo getmypid();
pcntl_async_signals(true);//开启异步监听信号
pcntl_signal(SIGUSR1,function(){
    echo "触发信号";
    posix_kill(getmypid(),SIGSTOP);
});
posix_kill(getmypid(),SIGSTOP);//给进程发送暂停信号

//b.php
posix_kill(文件1进程, SIGCONT);//给进程发送继续信号
posix_kill(文件1进程, SIGUSR1);//给进程发送user1信号

监听信号的包：

https://github.com/Rain-Life/monitorSignal