Raise unhandled exceptions in a thread in the main thread?

Question

There are some similar questions, but none supply the answer I require.

If I create threads via threading.Thread, which then throw exceptions which are unhandled, those threads are terminated. I wish to retain the default print out of the exception details with the stack trace, but bring down the whole process as well.

I've considered that it might be possible to catch all exceptions in the threads, and reraise them on the main thread object, or perhaps it's possible to manually perform the default exception handling, and then raise a SystemExit on the main thread.

What's the best way to go about this?

Solution 1

I wrote about Re-throwing exceptions in Python, including something very much like this as an example.

On your worker thread you do this (Python 3.x, see below for Python 2.x version):

try:
    self.result = self.do_something_dangerous()
except Exception as e:
    import sys
    self.exc_info = sys.exc_info()

and on your main thread:

if self.exc_info:
    raise self.exc_info[1].with_traceback(self.exc_info[2])
return self.result

Python 2.x:

try:
    self.result = self.do_something_dangerous()
except Exception, e:
    import sys
    self.exc_info = sys.exc_info()

and on your main thread you do this:

if self.exc_info:
    raise self.exc_info[1], None, self.exc_info[2]
return self.result

The exception will appear in the main thread just as if it had been raised in the worker thread.

Solution 2

The only exception a secondary thread can reliably raise in the main thread is KeyboardInterrupt: the way the secondary thread does it is by calling the function thread.interrupt_main(). There is no way to associate extra info (about the reason for the exception) with the exception object that gets raised -- the latter's always just a plain KeyboardInterrupt. So, you need to stash that information away somewhere else, e.g. on a dedicated instance of Queue.Queue -- that info might include the results the secondary thread can get via sys.exc_info(), and anything else you find useful of course.

The main thread will need to recover that extra info (and take into account that the queue will be empty if the keyboard interrupt is actually due to the user hitting control-C or the like, so, use get_nowait and be ready to deal with a Queue.Empty exception, for example), format it however you desire, and terminate (if all secondary threads are daemons, the whole process terminates when the main thread terminates).

Solution 3

Very unfortunately the accepted answer does not answer the question. You would rather pipe the exception details into a Queue. Please have a look at: Catch a thread's exception in the caller thread in Python

Comments

[Matt Joiner]

don't you mean to throw thrdobj.exc_info in the main thread, and why drop the exception type when you rethrow?

[Matt Joiner]

i see now, had to read up on 3arg raise statement. but the question about self still stands, thanks for a good answer, i'll try it out

[yantrab]

I'm not sure what your question about self is. This code came from an object that is used to defer work onto a worker thread, so the same object runs code in the worker and main threads.

[Robert Rossney]

I suspect the issue is not so much the mechanics of knowing how to re-raise the exception as when to, i.e. how does the main thread know that there's an exception waiting to be re-raised?

[ejm]

This answer stackoverflow.com/a/12223550 shows a nice way to encapsulate this into your Thread implementation, automatically re-raising the exception in the main thread when it calls join() on the worker thread.

[user2682863]

updated threading documentation link: docs.python.org/3.6/library/…