如何优雅地处理 SIGTERM 信号？

Posted 2023-02-22

【中文标题】如何优雅地处理 SIGTERM 信号？

【英文标题】：How to process SIGTERM signal gracefully?

【发布时间】：2013-09-01 05:04:03

【问题描述】：

假设我们有这样一个用 python 编写的琐碎的守护进程：

def mainloop():
    while True:
        # 1. do
        # 2. some
        # 3. important
        # 4. job
        # 5. sleep

mainloop()

我们使用start-stop-daemon 对其进行守护进程，默认情况下会在--stop 上发送SIGTERM (TERM) 信号。

假设当前执行的步骤是#2。而此时我们正在发送TERM 信号。

发生的情况是执行立即终止。

我发现我可以使用signal.signal(signal.SIGTERM, handler) 处理信号事件，但问题是它仍然会中断当前执行并将控制权传递给handler。

所以，我的问题是 - 是否可以不中断当前执行但在单独的线程中处理 TERM 信号（？），以便我能够设置 shutdown_flag = True 以便 mainloop() 有机会优雅地停下来？

【问题讨论】：

我之前通过使用signalfd 并屏蔽了SIGTERM 向进程的传递，完成了您的要求。

【参考方案1】：

捕捉信号时可以设置threading.Event。

threading.Event 是线程安全的，可以使用和传递，可以等待，并且可以从其他地方设置和清除相同的事件。

import signal, threading

quit_event = threading.Event()
signal.signal(signal.SIGTERM, lambda *_args: quit_event.set())

while not quit_event.is_set():
    print("Working...")

【参考方案2】：

我如何使用signal的代码示例：

#! /usr/bin/env python

import signal


def ctrl_handler(signum, frm):
    print "You can't cannot kill me"


print "Installing signal handler..."
signal.signal(signal.SIGINT, ctrl_handler)
print "done"

while True:
    # do something
    pass

【讨论】：

问题是如何优雅地退出 SIGTERM。您的示例显示了如何忽略 SIGINT。您可以更改为忽略 SIGTERM，但对于守护进程来说忽略它是一个坏主意，因为它会在超时后被 SIGKILL:ed 处理，并且根本无法忽略或优雅地处理。

【参考方案3】：

基于类的清洁使用解决方案：

import signal
import time

class GracefulKiller:
  kill_now = False
  def __init__(self):
    signal.signal(signal.SIGINT, self.exit_gracefully)
    signal.signal(signal.SIGTERM, self.exit_gracefully)

  def exit_gracefully(self, *args):
    self.kill_now = True

if __name__ == '__main__':
  killer = GracefulKiller()
  while not killer.kill_now:
    time.sleep(1)
    print("doing something in a loop ...")
   
  print("End of the program. I was killed gracefully :)")

【讨论】：

感谢您的建议！我在 reboot-guard 中使用了修改后的方法。 github.com/ryran/reboot-guard/blob/master/rguard#L284:L304

这是最好的答案（不需要线程），应该是首选的第一次尝试方法。

@Mausy5043 Python 允许您没有括号来定义类。虽然对于 python 3.x 来说非常好，但对于 python 2.x，最佳实践是使用“class XYZ(object):”。原因是：docs.python.org/2/reference/datamodel.html#newstyle

跟进，让你保持动力，谢谢。我一直用这个。

在更糟糕的情况下，这只是意味着在正常关闭之前进行另一次迭代。 False 值只设置一次，然后它只能从 False 变为 True，因此多访问不是问题。

【参考方案4】：

首先，我不确定您是否需要第二个线程来设置shutdown_flag。 为什么不直接在 SIGTERM 处理程序中设置呢？

另一种方法是从SIGTERM 处理程序中引发异常，该异常将向上传播到堆栈。假设您有适当的异常处理（例如使用with/contextmanager 和try: ... finally: 块），这应该是一个相当优雅的关闭，类似于您的程序 Ctrl+C .

示例程序signals-test.py:

#!/usr/bin/python

from time import sleep
import signal
import sys


def sigterm_handler(_signo, _stack_frame):
    # Raises SystemExit(0):
    sys.exit(0)

if sys.argv[1] == "handle_signal":
    signal.signal(signal.SIGTERM, sigterm_handler)

try:
    print "Hello"
    i = 0
    while True:
        i += 1
        print "Iteration #%i" % i
        sleep(1)
finally:
    print "Goodbye"

现在查看 Ctrl+C 行为：

$ ./signals-test.py default
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
^CGoodbye
Traceback (most recent call last):
  File "./signals-test.py", line 21, in <module>
    sleep(1)
KeyboardInterrupt
$ echo $?
1

这次我用kill $(ps aux | grep signals-test | awk '/python/ print $2') 4 次迭代后发送它SIGTERM：

$ ./signals-test.py default
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
Terminated
$ echo $?
143

这次我启用了我的自定义 SIGTERM 处理程序并将其发送到 SIGTERM：

$ ./signals-test.py handle_signal
Hello
Iteration #1
Iteration #2
Iteration #3
Iteration #4
Goodbye
$ echo $?
0

【讨论】：

"为什么不直接在 SIGTERM 处理程序中设置它" --- 因为工作线程会在随机位置中断。如果您将多个语句放入您的工作循环，您将看到您的解决方案在随机位置终止工作，这使工作处于未知状态。

对我来说效果很好，在 Docker 上下文中也是如此。谢谢！

如果您只是设置一个标志而不引发异常，那么它将与线程相同。所以在这里使用线程是多余的。

【参考方案5】：

我发现的最简单的解决方案是从上面的回复中汲取灵感

class SignalHandler:

    def __init__(self):

        # register signal handlers
        signal.signal(signal.SIGINT, self.exit_gracefully)
        signal.signal(signal.SIGTERM, self.exit_gracefully)

        self.logger = Logger(level=ERROR)

    def exit_gracefully(self, signum, frame):
        self.logger.info('captured signal %d' % signum)
        traceback.print_stack(frame)

        ###### do your resources clean up here! ####

        raise(SystemExit)

【讨论】：

通常不能在信号处理程序中进行资源清理，因为接收信号时它不知道程序在做什么。当然它有堆栈跟踪，但这几乎不足以做一些有用的事情。

在我的情况下，清理与运行程序代码有关，所以我确切地知道在关于外部进程时要安全关闭哪些资源（如数据库连接、挂起的套接字和 IO 等），就在我的情况下，我有管道程序（打开以在标准输入上输入），我什至可以在信号处理程序处关闭它们，因为我对它们中的每一个都有引用。但当然，这只适用于这种方法或类似方法。

exit_gracefully() 如何知道哪些数据库连接可以安全关闭？它如何等待它安全？

是的，这是特定于应用程序逻辑的，如果你有好的对象包装器，你可以这样做，但当然是特定于应用程序的，而且 - 我的两分钱 - 没有通用的解决方案！感谢您的 cmets。

【参考方案6】：

为我找到了最简单的方法。 这里是一个带有 fork 的示例，为了清楚起见，这种方式对流控制很有用。

import signal
import time
import sys
import os

def handle_exit(sig, frame):
    raise(SystemExit)

def main():
    time.sleep(120)

signal.signal(signal.SIGTERM, handle_exit)

p = os.fork()
if p == 0:
    main()
    os._exit()

try:
    os.waitpid(p, 0)
except (KeyboardInterrupt, SystemExit):
    print('exit handled')
    os.kill(p, 15)
    os.waitpid(p, 0)

【参考方案7】：

根据之前的答案，我创建了一个上下文管理器，可以防止 sigint 和 sigterm。

import logging
import signal
import sys


class TerminateProtected:
    """ Protect a piece of code from being killed by SIGINT or SIGTERM.
    It can still be killed by a force kill.

    Example:
        with TerminateProtected():
            run_func_1()
            run_func_2()

    Both functions will be executed even if a sigterm or sigkill has been received.
    """
    killed = False

    def _handler(self, signum, frame):
        logging.error("Received SIGINT or SIGTERM! Finishing this block, then exiting.")
        self.killed = True

    def __enter__(self):
        self.old_sigint = signal.signal(signal.SIGINT, self._handler)
        self.old_sigterm = signal.signal(signal.SIGTERM, self._handler)

    def __exit__(self, type, value, traceback):
        if self.killed:
            sys.exit(0)
        signal.signal(signal.SIGINT, self.old_sigint)
        signal.signal(signal.SIGTERM, self.old_sigterm)


if __name__ == '__main__':
    print("Try pressing ctrl+c while the sleep is running!")
    from time import sleep
    with TerminateProtected():
        sleep(10)
        print("Finished anyway!")
    print("This only prints if there was no sigint or sigterm")

【讨论】：

它似乎不支持嵌套的with TerminateProtected(): 语句。

@VyacheslavNapadovsky，它在进入时保留以前的处理程序并在（上下文）退出时恢复它们，所以对我来说还可以吗？

@AlexPeters，是的，但是当事件发生时您不会调用原始处理程序，因此任何处理程序都会被忽略。除此之外，我们还有异常处理机制，可以捕获和忽略 sys.exit(0) 抛出的异常，嵌套的 with 语句和中间的异常处理程序将导致忽略终止请求。 （并且让你按 ctrl+C）至少几次。

【参考方案8】：

这是一个没有线程或类的简单示例。

import signal

run = True

def handler_stop_signals(signum, frame):
    global run
    run = False

signal.signal(signal.SIGINT, handler_stop_signals)
signal.signal(signal.SIGTERM, handler_stop_signals)

while run:
    pass # do stuff including other IO stuff

【参考方案9】：

我认为您已经接近一个可能的解决方案。

在单独的线程中执行mainloop，并使用属性shutdown_flag 对其进行扩展。信号可以在主线程中用signal.signal(signal.SIGTERM, handler) 捕获（而不是在单独的线程中）。信号处理程序应将shutdown_flag 设置为True 并等待线程以thread.join() 结束

【讨论】：

是的，我终于解决了一个单独的线程，谢谢

这里不需要线程。在单线程程序本身中，可以先注册一个信号处理程序（注册一个信号处理程序是非阻塞的），然后编写mainloop。信号处理函数应该在何时设置一个标志，并且循环应该检查这个标志。我已经为同一个 here 粘贴了一个基于类的解决方案。

没有第二个线程是必要的。注册信号处理程序。

帮助页面：g-loaded.eu/2016/11/24/…