如何防止一段代码被Python中的KeyboardInterrupt中断？

Question

我在写一个程序，通过pickle模块缓存一些结果。会发生什么，此刻是，如果我打在CTRL-C，而dump操作正在发生，dump被中断，导致文件被破坏（即只有部分写的，所以它不能再load版

有一种方法，使dump，或一般的代码块，不间断我目前的解决方法看起来是这样的：？

try: 
    file = open(path, 'w') 
    dump(obj, file) 
    file.close() 
except KeyboardInterrupt: 
    file.close() 
    file.open(path,'w') 
    dump(obj, file) 
    file.close() 
    raise 

看来愚蠢，如果它被中断，重新启动的操作，所以我在寻找一种方式推迟中断。我该怎么做？

Answer 1

将函数放在一个线程中，然后等待线程完成。

Python线程不能被中断，除非有特殊的C api。

import time 
from threading import Thread 

def noInterrupt(): 
    for i in xrange(4): 
     print i 
     time.sleep(1) 

a = Thread(target=noInterrupt) 
a.start() 
a.join() 
print "done" 


0 
1 
2 
3 
Traceback (most recent call last): 
    File "C:\Users\Admin\Desktop\test.py", line 11, in <module> 
    a.join() 
    File "C:\Python26\lib\threading.py", line 634, in join 
    self.__block.wait() 
    File "C:\Python26\lib\threading.py", line 237, in wait 
    waiter.acquire() 
KeyboardInterrupt 

看看中断是如何推迟到线程完成的？

这适合于您的使用：

import time 
from threading import Thread 

def noInterrupt(path, obj): 
    try: 
     file = open(path, 'w') 
     dump(obj, file) 
    finally: 
     file.close() 

a = Thread(target=noInterrupt, args=(path,obj)) 
a.start() 
a.join() 

Answer 2

使用signal模块禁用SIGINT为过程的持续时间：

s = signal.signal(signal.SIGINT, signal.SIG_IGN) 
do_important_stuff() 
signal.signal(signal.SIGINT, s) 

Answer 3

在使用线程从此我的看法是矫枉过正。您可以确保文件被正确保存，只需做一个循环，直到成功写做：

def saveToFile(obj, filename): 
    file = open(filename, 'w') 
    cPickle.dump(obj, file) 
    file.close() 
    return True 

done = False 
while not done: 
    try: 
     done = saveToFile(obj, 'file') 
    except KeyboardInterrupt: 
     print 'retry' 
     continue 

Answer 4

以下是上下文管理，重视对SIGINT的信号处理程序。如果调用上下文管理器的信号处理程序，则在上下文管理器退出时仅通过将信号传递给原始处理程序来延迟信号。

import signal 
import logging 

class DelayedKeyboardInterrupt(object): 
    def __enter__(self): 
     self.signal_received = False 
     self.old_handler = signal.signal(signal.SIGINT, self.handler) 

    def handler(self, sig, frame): 
     self.signal_received = (sig, frame) 
     logging.debug('SIGINT received. Delaying KeyboardInterrupt.') 

    def __exit__(self, type, value, traceback): 
     signal.signal(signal.SIGINT, self.old_handler) 
     if self.signal_received: 
      self.old_handler(*self.signal_received) 

with DelayedKeyboardInterrupt(): 
    # stuff here will not be interrupted by SIGINT 
    critical_code()