signal —- 设置异步事件处理程序

signal —- 设置异步事件处理程序

该模块提供了在 Python 中使用信号处理程序的机制。

一般规则

signal.signal() 函数允许定义在接收到信号时执行的自定义处理程序。少量的默认处理程序已经设置： SIGPIPE 被忽略（因此管道和套接字上的写入错误可以报告为普通的 Python 异常）以及如果父进程没有更改 SIGINT ，则其会被翻译成 KeyboardInterrupt 异常。

一旦设置，特定信号的处理程序将保持安装，直到它被显式重置（ Python 模拟 BSD 样式接口而不管底层实现），但 SIGCHLD 的处理程序除外，它遵循底层实现。

执行 Python 信号处理程序

Python 信号处理程序不会在低级（ C ）信号处理程序中执行。相反，低级信号处理程序设置一个标志，告诉 virtual machine 稍后执行相应的 Python 信号处理程序（例如在下一个 bytecode 指令）。这会导致：

捕获同步错误是没有意义的，例如 SIGFPE 或 SIGSEGV ，它们是由 C 代码中的无效操作引起的。Python 将从信号处理程序返回到 C 代码，这可能会再次引发相同的信号，导致 Python 显然的挂起。从Python 3.3开始，你可以使用 faulthandler 模块来报告同步错误。
纯 C 中实现的长时间运行的计算（例如在大量文本上的正则表达式匹配）可以在任意时间内不间断地运行，而不管接收到任何信号。计算完成后将调用 Python 信号处理程序。

信号与线程

Python 信号处理程序总是在主 Python 线程中执行，即使信号是在另一个线程中接收的。这意味着信号不能用作线程间通信的手段。你可以使用 threading 模块中的同步原函数。

此外，只允许主线程设置新的信号处理程序。

模块内容

在 3.5 版更改: 信号（ SIG* ），处理程序（ SIG_DFL ， SIG_IGN）和 sigmask（ SIG_BLOCK ， SIG_UNBLOCK ， SIG_SETMASK ）下面列出的相关常量变成了 enums 。 getsignal() ， pthread_sigmask() ， sigpending() 和 sigwait() 函数返回人类可读的 enums 。

在 signal 模块中定义的变量是：

signal.SIG_DFL
这是两种标准信号处理选项之一；它只会执行信号的默认函数。例如，在大多数系统上，对于 SIGQUIT 的默认操作是转储核心并退出，而对于 SIGCHLD 的默认操作是简单地忽略它。

signal.SIG_IGN
这是另一个标准信号处理程序，它将简单地忽略给定的信号。

SIG*
All the signal numbers are defined symbolically. For example, the hangup signalis defined as signal.SIGHUP; the variable names are identical to thenames used in C programs, as found in <signal.h>. The Unix man page for'signal()' lists the existing signals (on some systems this issignal(2), on others the list is in signal(7)). Note thatnot all systems define the same set of signal names; only those names defined bythe system are defined by this module.

signal.CTRL_C_EVENT
对应于 Ctrl+C 击键事件的信号。此信号只能用于 os.kill() 。

可用性: Windows。

3.2 新版功能.

signal.CTRL_BREAK_EVENT
对应于 Ctrl+Break 击键事件的信号。此信号只能用于 os.kill() 。

可用性: Windows。

3.2 新版功能.

signal.NSIG
比最高信号数多一。

signal.ITIMER_REAL
实时递减间隔计时器，并在到期时发送 SIGALRM 。

signal.ITIMER_VIRTUAL
仅在进程执行时递减间隔计时器，并在到期时发送 SIGVTALRM 。

signal.ITIMER_PROF
Decrements interval timer both when the process executes and when thesystem is executing on behalf of the process. Coupled with ITIMER_VIRTUAL,this timer is usually used to profile the time spent by the applicationin user and kernel space. SIGPROF is delivered upon expiration.

signal.SIG_BLOCK
A possible value for the how parameter to pthread_sigmask()indicating that signals are to be blocked.

3.3 新版功能.

signal.SIG_UNBLOCK
A possible value for the how parameter to pthread_sigmask()indicating that signals are to be unblocked.

3.3 新版功能.

signal.SIG_SETMASK
A possible value for the how parameter to pthread_sigmask()indicating that the signal mask is to be replaced.

3.3 新版功能.

The signal module defines one exception:

exception signal.ItimerError
Raised to signal an error from the underlying setitimer() orgetitimer() implementation. Expect this error if an invalidinterval timer or a negative time is passed to setitimer().This error is a subtype of OSError.

3.3 新版功能: This error used to be a subtype of IOError, which is now analias of OSError.

The signal module defines the following functions:

signal.alarm(time)
If time is non-zero, this function requests that a SIGALRM signal besent to the process in time seconds. Any previously scheduled alarm iscanceled (only one alarm can be scheduled at any time). The returned value isthen the number of seconds before any previously set alarm was to have beendelivered. If time is zero, no alarm is scheduled, and any scheduled alarm iscanceled. If the return value is zero, no alarm is currently scheduled.

Availability: Unix. See the man page alarm(2) for furtherinformation.

signal.getsignal(signalnum)
Return the current signal handler for the signal signalnum. The returned valuemay be a callable Python object, or one of the special valuessignal.SIG_IGN, signal.SIG_DFL or None. Here,signal.SIG_IGN means that the signal was previously ignored,signal.SIG_DFL means that the default way of handling the signal waspreviously in use, and None means that the previous signal handler was notinstalled from Python.

signal.pause()
Cause the process to sleep until a signal is received; the appropriate handlerwill then be called. Returns nothing.

Availability: Unix. See the man page signal(2) for furtherinformation.

signal.pthreadkill(_thread_id, signalnum)
Send the signal signalnum to the thread thread_id, another thread in thesame process as the caller. The target thread can be executing any code(Python or not). However, if the target thread is executing the Pythoninterpreter, the Python signal handlers will be executed by the mainthread. Therefore, the only point of sending asignal to a particular Python thread would be to force a running system callto fail with InterruptedError.

Use threading.get_ident() or the identattribute of threading.Thread objects to get a suitable valuefor thread_id.

If signalnum is 0, then no signal is sent, but error checking is stillperformed; this can be used to check if the target thread is still running.

Availability: Unix. See the man page pthread_kill(3) for furtherinformation.

示例

Here is a minimal example program. It uses the alarm() function to limitthe time spent waiting to open a file; this is useful if the file is for aserial device that may not be turned on, which would normally cause theos.open() to hang indefinitely. The solution is to set a 5-second alarmbefore opening the file; if the operation takes too long, the alarm signal willbe sent, and the handler raises an exception.

import signal, os
 
def handler(signum, frame):
    print('Signal handler called with signal', signum)
    raise OSError("Couldn't open device!")
 
# Set the signal handler and a 5-second alarm
signal.signal(signal.SIGALRM, handler)
signal.alarm(5)
 
# This open() may hang indefinitely
fd = os.open('/dev/ttyS0', os.O_RDWR)
 
signal.alarm(0)          # Disable the alarm

Note on SIGPIPE

Piping output of your program to tools like head(1) willcause a SIGPIPE signal to be sent to your process when the receiverof its standard output closes early. This results in an exceptionlike BrokenPipeError: [Errno 32] Broken pipe. To handle thiscase, wrap your entry point to catch this exception as follows:

import os
import sys
 
def main():
    try:
        # simulate large output (your code replaces this loop)
        for x in range(10000):
            print("y")
        # flush output here to force SIGPIPE to be triggered
        # while inside this try block.
        sys.stdout.flush()
    except BrokenPipeError:
        # Python flushes standard streams on exit; redirect remaining output
        # to devnull to avoid another BrokenPipeError at shutdown
        devnull = os.open(os.devnull, os.O_WRONLY)
        os.dup2(devnull, sys.stdout.fileno())
        sys.exit(1)  # Python exits with error code 1 on EPIPE
 
if __name__ == '__main__':
    main()

Do not set SIGPIPE's disposition to SIG_DFLin order to avoid BrokenPipeError. Doing that would causeyour program to exit unexpectedly also whenever any socket connectionis interrupted while your program is still writing to it.