问题描述：

假设我们有一个用 Python 编写的简单守护进程：

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

mainloop()

我们使用它来start-stop-daemon对其进行守护进程，默认情况下它会发送SIGTERM（TERM）信号--stop。

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

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

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

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

解决方案 1：

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

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, signum, frame):
    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 :)")

解决方案 2：

首先，我不确定您是否需要第二个线程来设置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

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

$ ./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

解决方案 3：

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

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

解决方案 4：

我认为你已经接近找到可能的解决方案了。

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

解决方案 5：

根据前面的答案，我创建了一个用于保护 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")

解决方案 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, signal.SIGTERM)
    os.waitpid(p, 0)

解决方案 7：

与thoughtarray的答案类似，但使用asyncio：

loop = asyncio.get_event_loop()

def handle_signal(signum: int, frame: FrameType):
    loop.stop()
    # ...
    # additional steps to gracefully handle sigterm
    # ...
    sys.exit(signum)

signal.signal(signal.SIGINT, handle_signal)
signal.signal(signal.SIGTERM, handle_signal)
loop.run_forever()

假设任务是在 get_event_loop 获取的事件循环上安排的，并将在 sigterm 上停止循环

解决方案 8：

我发现的最简单的解决方案是，从上面的回复中得到启发

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)

解决方案 9：

您可以设置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...")

解决方案 10：

我使用的代码示例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

解决方案 11：

因此我想分享的是，当在 rasberry pi 上使用 python 脚本作为服务时，执行清理时服务停止会挂起终端。

解决方案是使用 os_exit(0) 强制退出，例如：def cleanup_and_exit_service(signal, frame):

做清理工作

os._exit(0)

信号.信号（信号.SIGTERM，cleanup_and_exit_service）

解决方案 12：

如果看到此内容的人正在使用 FastAPI，那么您也可以使用“关闭”事件：

app = FastAPI()

...

@app.on_event("shutdown")
async def shutdown():
    # Perform shutdown operations here