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

在一个单独的线程中执行mainloop，并使用属性shutdown_flag扩展它。这个信号可以用signal(信号)捕获。SIGTERM，处理器)在主线程(而不是在一个单独的线程中)。信号处理程序应该将shutdown_flag设置为True，并等待线程以thread.join()结束。

一个基于类的清洁使用解决方案:

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 :)")

您可以设置线程。事件，当捕获信号。

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

import signal, threading

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

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

根据前面的回答，我创建了一个上下文管理器，它可以保护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")

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

另一种方法是从SIGTERM处理程序引发异常，该异常将在堆栈中传播。假设你已经有了适当的异常处理(例如with/contextmanager和try:…这应该是一个相当优雅的关闭，类似于如果你要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

找到了对我来说最简单的方法。 这里有一个带有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)