python 2.6.x theading / Signals /atexit 在某些版本上失败？

Question

我已经看到很多与此相关的问题...但是我的代码在 python 2.6.2 上工作，而在 python 2.6.5 上失败。我是否错误地认为整个atexit“当程序被信号杀死时不会调用通过此模块注册的函数”，因为我正在捕获信号然后干净地退出，所以不应该在这里计数？这是怎么回事？执行此操作的正确方法是什么？

import atexit, sys, signal, time, threading

terminate = False
threads = []

def test_loop():
    while True:
        if terminate:
            print('stopping thread')
            break
        else:
            print('looping')
            time.sleep(1)

@atexit.register
def shutdown():
    global terminate
    print('shutdown detected')
    terminate = True
    for thread in threads:
        thread.join()

def close_handler(signum, frame):
    print('caught signal')
    sys.exit(0)

def run():
    global threads
    thread = threading.Thread(target=test_loop)
    thread.start()
    threads.append(thread)

    while True:
        time.sleep(2)
        print('main')

signal.signal(signal.SIGINT, close_handler)

if __name__ == "__main__":
    run()

python 2.6.2:

$ python halp.py 
looping
looping
looping
main
looping
main
looping
looping
looping
main
looping
^Ccaught signal
shutdown detected
stopping thread

python 2.6.5:

$ python halp.py 
looping
looping
looping
main
looping
looping
main
looping
looping
main
^Ccaught signal
looping
looping
looping
looping
...
looping
looping
Killed <- kill -9 process at this point

2.6.5 上的主线程似乎从不执行 atexit 函数。

Answer 1

这里的根本区别实际上与信号和 atexit 无关，而是 sys.exit 行为的变化。

在 2.6.5 左右之前，sys.exit（更准确地说，SystemExit 在顶层被捕获）会导致解释器退出；如果线程仍在运行，它们将被终止，就像 POSIX 线程一样。

在 2.6.5 左右，行为发生了变化：现在 sys.exit 的效果与从程序主函数返回的效果基本相同。当您这样做时（在两个版本中），解释器都会等待所有线程加入后再退出。

相关的变化是，Py_Finalize 现在在顶部附近调用 wait_for_thread_shutdown()，而以前不会。

这种行为改变似乎是不正确的，主要是因为它不再按照记录的方式运行，这只是：“从 Python 退出”。实际效果不再是退出Python，而只是简单地退出线程。 （顺便说一句，当从另一个线程调用时，sys.exit 从未退出过 Python，但是与记录的行为之间的模糊差异并不能证明更大的差异

是合理的。）我可以看到新行为：退出主线程的方法不是两种（“退出并等待线程”和“立即退出”），而是只有一种，因为 sys.exit 本质上与简单地从顶部函数返回相同。然而，这是一个突破性的改变，并且与记录的行为背道而驰，这远远超过了这一点。

由于此更改，在从上面的信号处理程序 sys.exit 后，解释器会等待线程退出，然后在线程退出后运行 atexit 处理程序。由于处理程序本身告诉线程退出，因此结果是死锁。

Answer 2

由于信号而退出与从信号处理程序内退出不同。捕获信号并使用 sys.exit 退出是干净的退出，而不是由于信号处理程序而退出。所以，是的，我同意它应该在这里运行 atexit 处理程序——至少原则上如此。

然而，信号处理程序有一些棘手的地方：它们是完全异步的。它们可以随时在任何 VM 操作码之间中断程序流。以这段代码为例。 （将其视为与上面的代码相同的形式；为了简洁起见，我省略了代码。）

import threading
lock = threading.Lock()
def test_loop():
    while not terminate:
        print('looping')
        with lock:
             print "Executing synchronized operation"
        time.sleep(1)
    print('stopping thread')

def run():
    while True:
        time.sleep(2)
        with lock:
             print "Executing another synchronized operation"
        print('main')

这里有一个严重的问题：当 run() 持有 lock 时，可能会收到信号（例如 ^C）代码>.如果发生这种情况，您的信号处理程序将在仍保持锁定的情况下运行。然后它将等待 test_loop 退出，如果该线程正在等待锁，则会出现死锁。

这是一整类问题，这就是为什么很多 API 都说不要从信号处理程序中调用它们。相反，您应该设置一个标志来告诉主线程在适当的时间关闭。

do_shutdown = False
def close_handler(signum, frame):
    global do_shutdown
    do_shutdown = True
    print('caught signal')

def run():
    while not do_shutdown:
        ...

我的偏好是避免完全使用 sys.exit 退出程序，并在主退出点（例如 run() 结束）显式进行清理，但如果需要，您可以在此处使用 atexit。

Answer 3

我不确定这是否完全改变了，但这就是我在 2.6.5 中完成 atexit 的方式

atexit.register(goodbye)

def goodbye():
    print "\nStopping..."