你可以简单地在你的线程中抛出一个错误，让主线程处理并报告这个错误，然后你甚至可以终止程序。
例如，在您的工作线程上：

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

在主线程上：

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

所以为了给予你一个更完整的画面，你的代码可能看起来像这样：

import threading

class ExcThread(threading.Thread):
    def excRun(self):
        pass
        #Where your core program will run

    def run(self):
        self.exc = None
        try:
        # Possibly throws an exception
            self.excRun()
        except:
            import sys
            self.exc = sys.exc_info()
            # Save details of the exception thrown 
            # DON'T rethrow,
            # just complete the function such as storing
            # variables or states as needed

    def join(self):
        threading.Thread.join(self)
        if self.exc:
            msg = "Thread '%s' threw an exception: %s" % (self.getName(), self.exc[1])
            new_exc = Exception(msg)
            raise new_exc.with_traceback(self.exc[2])

（我额外添加了一行代码来记录是哪个线程导致了错误，以防你有多个线程，给它们命名也是一个很好的习惯）

我的解决方案最终是solution posted here和上面的SIGKILL解决方案的完美结合。我将以下killall.py子模块添加到我的包中：

import threading
import sys
import traceback
import os
import signal

def sendKillSignal(etype, value, tb):
    print('KILL ALL')
    traceback.print_exception(etype, value, tb)
    os.kill(os.getpid(), signal.SIGKILL)

original_init = threading.Thread.__init__
def patched_init(self, *args, **kwargs):
    print("thread init'ed")
    original_init(self, *args, **kwargs)
    original_run = self.run
    def patched_run(*args, **kw):
        try:
            original_run(*args, **kw)
        except:
            sys.excepthook(*sys.exc_info())
    self.run = patched_run

def install():
    sys.excepthook = sendKillSignal
    threading.Thread.__init__ = patched_init

然后在启动任何其他线程（我自己创建的或从其他导入的库）之前立即运行install。

我只是想分享我的简单解决方案。
在我的例子中，我希望异常正常显示，但随后立即停止程序。我能够通过启动一个定时器线程来实现这一点，在引发异常之前有一个小的延迟来调用os._exit。

import os
import threading

def raise_and_exit(args):
    threading.Timer(0.01, os._exit, args=(1,)).start()
    raise args[0]

threading.excepthook = raise_and_exit

Python 3.8添加了threading.excepthook，这使得可以更干净地处理它。
我写了一个包“unhandled_exit”来完成这个任务。它基本上是在默认处理程序之后添加os._exit(1)。这意味着在进程退出之前可以获得正常的回溯。
软件包在这里发布到pypi：https://pypi.org/project/unhandled_exit/
代码在这里：https://github.com/rfjakob/unhandled_exit/blob/master/unhandled_exit/__init__.py
用法很简单：

import unhandled_exit
unhandled_exit.activate()