我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用atexit._run_exitfuncs()。
def _run_exitfuncs(): """run any registered exit functions _exithandlers is traversed in reverse order so functions are executed last in, first out. """ exc_info = None while _exithandlers: func, targs, kargs = _exithandlers.pop() try: func(*targs, **kargs) except SystemExit: exc_info = sys.exc_info() except: import traceback sys.stderr.write("Error in atexit._run_exitfuncs:\n") traceback.print_exc() exc_info = sys.exc_info() if exc_info is not None: raise exc_info[0](exc_info[1])
def exit(): """ Causes python to exit without garbage-collecting any objects, and thus avoids calling object destructor methods. This is a sledgehammer workaround for a variety of bugs in PyQt and Pyside that cause crashes on exit. This function does the following in an attempt to 'safely' terminate the process: * Invoke atexit callbacks * Close all open file handles * os._exit() Note: there is some potential for causing damage with this function if you are using objects that _require_ their destructors to be called (for example, to properly terminate log files, disconnect from devices, etc). Situations like this are probably quite rare, but use at your own risk. """ ## first disable our own cleanup function; won't be needing it. setConfigOptions(exitCleanup=False) ## invoke atexit callbacks atexit._run_exitfuncs() ## close file handles if sys.platform == 'darwin': for fd in range(3, 4096): if fd not in [7]: # trying to close 7 produces an illegal instruction on the Mac. os.close(fd) else: os.closerange(3, 4096) ## just guessing on the maximum descriptor count.. os._exit(0) ## Convenience functions for command-line use
def test_args(self): # be sure args are handled properly atexit.register(h1) atexit.register(h4) atexit.register(h4, 4, kw="abc") atexit._run_exitfuncs() self.assertEqual(self.stream.getvalue(), "h4 (4,) {'kw': 'abc'}\nh4 () {}\nh1\n")
def test_badargs(self): atexit.register(lambda: 1, 0, 0, (x for x in (1,2)), 0, 0) self.assertRaises(TypeError, atexit._run_exitfuncs)
def test_order(self): # be sure handlers are executed in reverse order atexit.register(h1) atexit.register(h2) atexit.register(h3) atexit._run_exitfuncs() self.assertEqual(self.stream.getvalue(), "h3\nh2\nh1\n")
def test_raise(self): # be sure raises are handled properly atexit.register(raise1) atexit.register(raise2) self.assertRaises(TypeError, atexit._run_exitfuncs)
def test_raise_unnormalized(self): # Issue #10756: Make sure that an unnormalized exception is # handled properly atexit.register(lambda: 1 / 0) self.assertRaises(ZeroDivisionError, atexit._run_exitfuncs) self.assertIn("ZeroDivisionError", self.stream.getvalue())
def test_clear(self): a = [0] def inc(): a[0] += 1 atexit.register(inc) atexit._clear() atexit._run_exitfuncs() self.assertEqual(a[0], 0)
def test_unregister(self): a = [0] def inc(): a[0] += 1 def dec(): a[0] -= 1 for i in range(4): atexit.register(inc) atexit.register(dec) atexit.unregister(inc) atexit._run_exitfuncs() self.assertEqual(a[0], -1)
def test_bound_methods(self): l = [] atexit.register(l.append, 5) atexit._run_exitfuncs() self.assertEqual(l, [5]) atexit.unregister(l.append) atexit._run_exitfuncs() self.assertEqual(l, [5])
def test_args(self): atexit.register(self.h1) atexit.register(self.h4) atexit.register(self.h4, 4, kw="abc") atexit._run_exitfuncs() self.assertEqual(self.subst_io.getvalue(), "h4 (4,) {'kw': 'abc'}\nh4 () {}\nh1\n")
def test_order(self): atexit.register(self.h1) atexit.register(self.h2) atexit.register(self.h3) atexit._run_exitfuncs() self.assertEqual(self.subst_io.getvalue(), "h3\nh2\nh1\n")
def test_sys_override(self): # be sure a preset sys.exitfunc is handled properly exfunc = sys.exitfunc sys.exitfunc = self.h1 reload(atexit) try: atexit.register(self.h2) atexit._run_exitfuncs() finally: sys.exitfunc = exfunc self.assertEqual(self.subst_io.getvalue(), "h2\nh1\n")
def test_raise(self): atexit.register(self.raise1) atexit.register(self.raise2) self.assertRaises(TypeError, atexit._run_exitfuncs) ### helpers
def test_stress(self): a = [0] def inc(): a[0] += 1 for i in range(128): atexit.register(inc) atexit._run_exitfuncs() self.assertEqual(a[0], 128)
def handle_exit(): import atexit atexit._run_exitfuncs()
def exit(exitcode=0): """ Causes python to exit without garbage-collecting any objects, and thus avoids calling object destructor methods. This is a sledgehammer workaround for a variety of bugs in PyQt and Pyside that cause crashes on exit. This function does the following in an attempt to 'safely' terminate the process: * Invoke atexit callbacks * Close all open file handles * os._exit() Note: there is some potential for causing damage with this function if you are using objects that _require_ their destructors to be called (for example, to properly terminate log files, disconnect from devices, etc). Situations like this are probably quite rare, but use at your own risk. @param int exitcode: system exit code """ if has_pyqtgraph: # first disable our pyqtgraph's cleanup function; won't be needing it. pyqtgraph.setConfigOptions(exitCleanup=False) # invoke atexit callbacks atexit._run_exitfuncs() # close file handles if sys.platform == 'darwin': for fd in range(3, 4096): # trying to close 7 produces an illegal instruction on the Mac. if fd not in [7]: os.close(fd) else: # just guessing on the maximum descriptor count.. os.closerange(3, 4096) os._exit(exitcode)
