让我们假设我们用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(信号。SIGTERM，处理程序)，但问题是它仍然中断当前执行并将控制传递给处理程序。
所以，我的问题是-是否有可能不中断当前的执行，而是在一个分离的线程中处理TERM信号(?)，以便我能够设置shutdown_flag = True，以便mainloop()有机会优雅地停止?
当前回答
首先，我不确定是否需要第二个线程来设置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
其他回答
下面是一个没有线程或类的简单示例。
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
找到了对我来说最简单的方法。 这里有一个带有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)
我认为你已经接近一个可能的解决方案了。
在一个单独的线程中执行mainloop，并使用属性shutdown_flag扩展它。这个信号可以用signal(信号)捕获。SIGTERM，处理器)在主线程(而不是在一个单独的线程中)。信号处理程序应该将shutdown_flag设置为True，并等待线程以thread.join()结束。
您可以设置线程。事件，当捕获信号。
线程。事件是线程安全的，可以使用和传递，可以等待，同样的事件可以从其他地方设置和清除。
import signal, threading
quit_event = threading.Event()
signal.signal(signal.SIGTERM, lambda *_args: quit_event.set())
while not quit_event.is_set():
print("Working...")
我找到的最简单的解决方法，从上面的回答中获得灵感是
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)
