如何优雅地处理SIGTERM信号?

让我们假设我们用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()有机会优雅地停止?

250015 次浏览
小开

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

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

小开

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

另一种方法是从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
小开
最佳答案

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

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


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
小开

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

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

我找到的最简单的解决方法，从上面的回答中获得灵感是

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)
小开

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

你可以在捕捉信号时设置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...")

提交答案