Windows 中的 PHP CLI：处理 Ctrl-C 命令？

Question

如何在命令行中处理 PHP 中的 CTRL+C？ Pcntl_* 函数在 Windows 中不起作用。

Answer 1

从 PHP 7.4 开始，现在可以通过使用 sapi_windows_set_ctrl_handler() 函数注册处理程序回调来实现。

这是由sapi_windows_generate_ctrl_event() 补充的，它可用于将信号分派到与调用者连接到同一控制台的其他进程。

只有 CTRL-C 和 CTRL-BREAK 事件可以在用户空间中处理，关闭/注销/关闭事件不能安全地实现，因为到那时操作系统可能会处于不可预知的部分关闭状态处理函数被调用，因此此时执行的任何代码都存在弊大于利的风险。

你可以在 MSDN 上找到更多关于底层机制的信息：

• SetConsoleCtrlHandler()
• GenerateConsoleCtrlEvent()

PHP API 与底层 C API 几乎相同，唯一显着的区别是 PHP 只允许注册单个回调，因此处理程序没有有意义的返回值，引擎只是标记事件如处理。这是为了保持实现简单，因为一堆函数可以很容易地在用户空间中实现，同样如果你不想处理事件，你可以简单地调用exit。

Answer 2

以下适用于 unix 系统。

我们可以使用stream_get_contents() 捕获键，但它不能捕获 CTRL 键。过滤^C 也不起作用。

我们需要做的是抓住SIGINT posix signal。

抑制 CTRL + c 默认行为。

程序不会退出，你需要然后implement another way of exiting!:

function shutdown(){};
pcntl_signal(SIGINT,"shutdown");

处理CTRL + c，并在退出前运行一些代码：

function shutdown(){
    echo "\033c";                                        // Clear terminal
    system("tput cnorm && tput cup 0 0 && stty echo");   // Restore cursor default
    echo PHP_EOL;                                        // New line
    exit;                                                // Clean quit 
}

register_shutdown_function("shutdown");                  // Handle END of script

declare(ticks = 1);                                      // Allow posix signal handling
pcntl_signal(SIGINT,"shutdown");                         // Catch SIGINT, run shutdown()                    

---

POSIX 信号列表：

Php 不会捕获 SIGKILL，不可能。

SIGABRT and SIGIOT
    The SIGABRT and SIGIOT signal is sent to a process to tell it to abort, i.e. to terminate. The signal is usually initiated by the process itself when it calls abort() function of the C Standard Library, but it can be sent to the process from outside like any other signal.
SIGALRM, SIGVTALRM and SIGPROF
    The SIGALRM, SIGVTALRM and SIGPROF signal is sent to a process when the time limit specified in a call to a preceding alarm setting function (such as setitimer) elapses. SIGALRM is sent when real or clock time elapses. SIGVTALRM is sent when CPU time used by the process elapses. SIGPROF is sent when CPU time used by the process and by the system on behalf of the process elapses.
SIGBUS
    The SIGBUS signal is sent to a process when it causes a bus error. The conditions that lead to the signal being sent are, for example, incorrect memory access alignment or non-existent physical address.
SIGCHLD
    The SIGCHLD signal is sent to a process when a child process terminates, is interrupted, or resumes after being interrupted. One common usage of the signal is to instruct the operating system to clean up the resources used by a child process after its termination without an explicit call to the wait system call.
SIGCONT
    The SIGCONT signal instructs the operating system to continue (restart) a process previously paused by the SIGSTOP or SIGTSTP signal. One important use of this signal is in job control in the Unix shell.
SIGFPE
    The SIGFPE signal is sent to a process when it executes an erroneous arithmetic operation, such as division by zero. This may include integer division by zero, and integer overflow in the result of a divide (only INT_MIN/-1, INT64_MIN/-1 and %-1 accessible from C).[2][3].
SIGHUP
    The SIGHUP signal is sent to a process when its controlling terminal is closed. It was originally designed to notify the process of a serial line drop (a hangup). In modern systems, this signal usually means that the controlling pseudo or virtual terminal has been closed.[4] Many daemons will reload their configuration files and reopen their logfiles instead of exiting when receiving this signal.[5] nohup is a command to make a command ignore the signal.
SIGILL
    The SIGILL signal is sent to a process when it attempts to execute an illegal, malformed, unknown, or privileged instruction.
SIGINT
    The SIGINT signal is sent to a process by its controlling terminal when a user wishes to interrupt the process. This is typically initiated by pressing Ctrl+C, but on some systems, the "delete" character or "break" key can be used.[6]
SIGKILL
    The SIGKILL signal is sent to a process to cause it to terminate immediately (kill). In contrast to SIGTERM and SIGINT, this signal cannot be caught or ignored, and the receiving process cannot perform any clean-up upon receiving this signal. The following exceptions apply:

        Zombie processes cannot be killed since they are already dead and waiting for their parent processes to reap them.
        Processes that are in the blocked state will not die until they wake up again.
        The init process is special: It does not get signals that it does not want to handle, and thus it can ignore SIGKILL.[7] An exception from this exception is while init is ptraced on Linux.[8][9]
        An uninterruptibly sleeping process may not terminate (and free its resources) even when sent SIGKILL. This is one of the few cases in which a UNIX system may have to be rebooted to solve a temporary software problem.

    SIGKILL is used as a last resort when terminating processes in most system shutdown procedures if it does not voluntarily exit in response to SIGTERM. To speed the computer shutdown procedure, Mac OS X 10.6, aka Snow Leopard, will send SIGKILL to applications that have marked themselves "clean" resulting in faster shutdown times with, presumably, no ill effects.[10] The command killall -9 has a similar, while dangerous effect, when executed e.g. in Linux; it doesn't let programs save unsaved data. It has other options, and with none, uses the safer SIGTERM signal.
SIGPIPE
    The SIGPIPE signal is sent to a process when it attempts to write to a pipe without a process connected to the other end.
SIGPOLL
    The SIGPOLL signal is sent when an event occurred on an explicitly watched file descriptor.[11] Using it effectively leads to making asynchronous I/O requests since the kernel will poll the descriptor in place of the caller. It provides an alternative to active polling.
SIGRTMIN to SIGRTMAX
    The SIGRTMIN to SIGRTMAX signals are intended to be used for user-defined purposes. They are real-time signals.
SIGQUIT
    The SIGQUIT signal is sent to a process by its controlling terminal when the user requests that the process quit and perform a core dump.
SIGSEGV
    The SIGSEGV signal is sent to a process when it makes an invalid virtual memory reference, or segmentation fault, i.e. when it performs a segmentation violation.[12]
SIGSTOP
    The SIGSTOP signal instructs the operating system to stop a process for later resumption.
SIGSYS
    The SIGSYS signal is sent to a process when it passes a bad argument to a system call. In practice, this kind of signal is rarely encountered since applications rely on libraries (e.g. libc) to make the call for them. SIGSYS can be received by applications violating the Linux Seccomp security rules configured to restrict them.
SIGTERM
    The SIGTERM signal is sent to a process to request its termination. Unlike the SIGKILL signal, it can be caught and interpreted or ignored by the process. This allows the process to perform nice termination releasing resources and saving state if appropriate. SIGINT is nearly identical to SIGTERM.
SIGTSTP
    The SIGTSTP signal is sent to a process by its controlling terminal to request it to stop (terminal stop). It is commonly initiated by the user pressing Ctrl+Z. Unlike SIGSTOP, the process can register a signal handler for, or ignore, the signal.
SIGTTIN and SIGTTOU
    The SIGTTIN and SIGTTOU signals are sent to a process when it attempts to read in or write out respectively from the tty while in the background. Typically, these signals are received only by processes under job control; daemons do not have controlling terminals and, therefore, should never receive these signals.
SIGTRAP
    The SIGTRAP signal is sent to a process when an exception (or trap) occurs: a condition that a debugger has requested to be informed of – for example, when a particular function is executed, or when a particular variable changes value.
SIGURG
    The SIGURG signal is sent to a process when a socket has urgent or out-of-band data available to read.
SIGUSR1 and SIGUSR2
    The SIGUSR1 and SIGUSR2 signals are sent to a process to indicate user-defined conditions.
SIGXCPU
    The SIGXCPU signal is sent to a process when it has used up the CPU for a duration that exceeds a certain predetermined user-settable value.[13] The arrival of a SIGXCPU signal provides the receiving process a chance to quickly save any intermediate results and to exit gracefully, before it is terminated by the operating system using the SIGKILL signal.
SIGXFSZ
    The SIGXFSZ signal is sent to a process when it grows a file that exceeds the maximum allowed size.
SIGWINCH
    The SIGWINCH signal is sent to a process when its controlling terminal changes its size (a window change).[14]

Answer 3

如果您想通过命令行在 PHP 中运行需要很长时间的任务，我会尝试将其组织在徽章中并跟踪已经完成的工作。

现在您可以完全处理每个徽章（例如：处理然后将其存储在 xml 文件中），而不仅仅是在处理整个列表之后。因此，两者之间的崩溃/停止只会取消一个徽章，而不是全部。

如果您将当前位置存储在每个徽章之后的某个位置，您可以在脚本崩溃或停止时轻松恢复。

现在，如果您检查操作系统进程列表以查看您的脚本是否正在运行，您可以编写一个 cron 作业，如果脚本已崩溃且尚未运行，则该作业每 X 分钟启动一次。

所以，TL;DR

• 在小徽章中处理作业
• 上一次成功处理的徽章的存储位置
• 在启动时检查已经运行的进程
• 不断启动脚本，直到所有人都满意为止！

除此之外，我喜欢 PHP 用于小型命令行工作，但如果您有如此大的任务，其他的可能更适合。检查可以长时间稳定运行并具有显示进度的方法。也许是一个带有简约 gui 的小型 C# 应用程序。