我对Python和多线程编程非常陌生。基本上，我有一个脚本，将文件复制到另一个位置。我希望将它放在另一个线程中，这样我就可以输出....来表示脚本仍在运行。
我遇到的问题是，如果无法复制文件，它将引发异常。如果在主线程中运行，这是可以的;但是，使用以下代码不起作用：
try:
threadClass = TheThread(param1, param2, etc.)
threadClass.start() ##### **Exception takes place here**
except:
print "Caught an exception"
在线程类本身，我试图重新抛出异常，但它不起作用。我看到这里的人问类似的问题，但他们似乎都在做一些比我想做的更具体的事情（而且我不太了解提供的解决方案）。我看到有人提到sys.exc_info()的用法，但我不知道在哪里或如何使用它。
非常感谢所有帮助！
编辑：线程类的代码如下：
class TheThread(threading.Thread):
def __init__(self, sourceFolder, destFolder):
threading.Thread.__init__(self)
self.sourceFolder = sourceFolder
self.destFolder = destFolder
def run(self):
try:
shul.copytree(self.sourceFolder, self.destFolder)
except:
raise
答案 0 :(得分：96)
问题是thread_obj.start()立即返回。您生成的子线程在其自己的上下文中执行，具有自己的堆栈。发生在那里的任何异常都存在于子线程的上下文中，并且它位于自己的堆栈中。我现在可以想到将这些信息传递给父线程的一种方法是使用某种消息传递，所以你可能会研究它。
尝试使用此尺寸：
import sys
import threading
import Queue
class ExcThread(threading.Thread):
def __init__(self, bucket):
threading.Thread.__init__(self)
self.bucket = bucket
def run(self):
try:
raise Exception('An error occured here.')
except Exception:
self.bucket.put(sys.exc_info())
def main():
bucket = Queue.Queue()
thread_obj = ExcThread(bucket)
thread_obj.start()
while True:
try:
exc = bucket.get(block=False)
except Queue.Empty:
pass
else:
exc_type, exc_obj, exc_trace = exc
# deal with the exception
print exc_type, exc_obj
print exc_trace
thread_obj.join(0.1)
if thread_obj.isAlive():
continue
else:
break
if __name__ == '__main__':
main()
答案 1 :(得分：31)
concurrent.futures模块使得在单独的线程（或进程）中工作变得简单并处理任何产生的异常：
import concurrent.futures
import shutil
def copytree_with_dots(src_path, dst_path):
with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
# Execute the copy on a separate thread,
# creating a future object to track progress.
future = executor.submit(shutil.copytree, src_path, dst_path)
while future.running():
# Print pretty dots here.
pass
# Return the value returned by shutil.copytree(), None.
# Raise any exceptions raised during the copy process.
return future.result()
concurrent.futures包含在Python 3.2中，可用于早期版本的the backported futures module。
答案 2 :(得分：27)
虽然无法直接捕获在不同线程中抛出的异常，但这里有一个代码可以非常透明地获得非常接近此功能的内容。您的子线程必须继承ExThread类而不是threading.Thread，并且在等待线程完成其工作时，父线程必须调用child_thread.join_with_exception()方法而不是child_thread.join()。< / p>
此实现的技术细节：当子线程抛出异常时，它将通过Queue传递给父级，并在父级线程中再次抛出。请注意，这种方法没有繁忙的等待。
#!/usr/bin/env python
import sys
import threading
import Queue
class ExThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.__status_queue = Queue.Queue()
def run_with_exception(self):
"""This method should be overriden."""
raise NotImplementedError
def run(self):
"""This method should NOT be overriden."""
try:
self.run_with_exception()
except BaseException:
self.__status_queue.put(sys.exc_info())
self.__status_queue.put(None)
def wait_for_exc_info(self):
return self.__status_queue.get()
def join_with_exception(self):
ex_info = self.wait_for_exc_info()
if ex_info is None:
return
else:
raise ex_info[1]
class MyException(Exception):
pass
class MyThread(ExThread):
def __init__(self):
ExThread.__init__(self)
def run_with_exception(self):
thread_name = threading.current_thread().name
raise MyException("An error in thread '{}'.".format(thread_name))
def main():
t = MyThread()
t.start()
try:
t.join_with_exception()
except MyException as ex:
thread_name = threading.current_thread().name
print "Caught a MyException in thread '{}': {}".format(thread_name, ex)
if __name__ == '__main__':
main()
答案 3 :(得分：17)
如果线程中发生异常，最好的方法是在join期间在调用者线程中重新提升它。您可以使用sys.exc_info()函数获取有关当前正在处理的异常的信息。这个信息可以简单地存储为线程对象的属性，直到调用join为止，此时可以重新引发它。
请注意，在这个简单的情况下，最多抛出一个异常并且在抛出异常后立即完成时，不需要Queue.Queue（如其他答案所示） 。我们通过简单地等待线程完成来避免竞争条件。
例如，展开ExcThread（下方），覆盖excRun（而不是run）。
Python 2.x：
import threading
class ExcThread(threading.Thread):
def excRun(self):
pass
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 but don't rethrow,
# just complete the function
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.__class__, new_exc, self.exc[2]
Python 3.x：
{3}的3参数形式在Python 3中消失了，所以将最后一行改为：
raise答案 4 :(得分：12)
这个问题有很多非常复杂的答案。我是否过度简化了这一点，因为这对我来说似乎已经足够了。
from threading import Thread
class PropagatingThread(Thread):
def run(self):
self.exc = None
try:
if hasattr(self, '_Thread__target'):
# Thread uses name mangling prior to Python 3.
self.ret = self._Thread__target(*self._Thread__args, **self._Thread__kwargs)
else:
self.ret = self._target(*self._args, **self._kwargs)
except BaseException as e:
self.exc = e
def join(self):
super(PropagatingThread, self).join()
if self.exc:
raise self.exc
return self.ret
如果您确定自己只会在一个或另一个版本的Python上运行，那么您可以将run()方法缩减为仅限于错误版本（如果您＆＃39 ; ll只能在3）之前的Python版本上运行，或者只是干净的版本（如果你只是在从3开始的Python版本上运行）。
使用示例：
def f(*args, **kwargs)
print(args)
print(kwargs)
raise Exception('I suck')
t = PropagatingThread(target=f, args=(5,), kwargs={'hello':'world'})
t.start()
t.join()
当你加入时，你会看到另一个帖子上引发的异常。
答案 5 :(得分：6)
在Python 3.8中，我们可以使用threading.excepthook来挂钩所有子线程中未捕获的异常！例如，
threading.excepthook = thread_exception_handler
答案 6 :(得分：4)
这是一个令人讨厌的小问题，我想把我的解决方案投入使用。我发现的其他一些解决方案（例如async.io）看起来很有前途，但也提出了一些黑盒子。队列/事件循环方法将您绑定到某个实现。 The concurrent futures source code, however, is around only 1000 lines, and easy to comprehend。它允许我轻松解决我的问题：创建ad-hoc工作线程而不需要太多设置，并且能够捕获主线程中的异常。
我的解决方案使用并发期货API和线程API。它允许您创建一个工具，为您提供线程和未来。这样，您可以加入线程以等待结果：
worker = Worker(test)
thread = worker.start()
thread.join()
print(worker.future.result())
...或者您可以让工作人员在完成后发送回调：
worker = Worker(test)
thread = worker.start(lambda x: print('callback', x))
...或者您可以循环直到事件完成：
worker = Worker(test)
thread = worker.start()
while True:
print("waiting")
if worker.future.done():
exc = worker.future.exception()
print('exception?', exc)
result = worker.future.result()
print('result', result)
break
time.sleep(0.25)
以下是代码：
from concurrent.futures import Future
import threading
import time
class Worker(object):
def __init__(self, fn, args=()):
self.future = Future()
self._fn = fn
self._args = args
def start(self, cb=None):
self._cb = cb
self.future.set_running_or_notify_cancel()
thread = threading.Thread(target=self.run, args=())
thread.daemon = True #this will continue thread execution after the main thread runs out of code - you can still ctrl + c or kill the process
thread.start()
return thread
def run(self):
try:
self.future.set_result(self._fn(*self._args))
except BaseException as e:
self.future.set_exception(e)
if(self._cb):
self._cb(self.future.result())
...和测试功能：
def test(*args):
print('args are', args)
time.sleep(2)
raise Exception('foo')
答案 7 :(得分：3)
concurrent.futures.as_completed
https://docs.python.org/3.7/library/concurrent.futures.html#concurrent.futures.as_completed
以下解决方案：
Queue 来源：
#!/usr/bin/env python3
import concurrent.futures
import time
def func_that_raises(do_raise):
for i in range(3):
print(i)
time.sleep(0.1)
if do_raise:
raise Exception()
for i in range(3):
print(i)
time.sleep(0.1)
with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
futures = []
futures.append(executor.submit(func_that_raises, False))
futures.append(executor.submit(func_that_raises, True))
for future in concurrent.futures.as_completed(futures):
print(repr(future.exception()))
可能的输出：
0
0
1
1
2
2
0
Exception()
1
2
None
不幸的是，由于一个交易失败，不可能杀死期货以取消其他交易：
concurrent.features; Python: concurrent.futures How to make it cancelable? threading：Is there any way to kill a Thread? 如果您执行以下操作：
for future in concurrent.futures.as_completed(futures):
if future.exception() is not None:
raise future.exception()
然后with捕获它，并等待第二个线程完成后再继续。以下行为类似：
for future in concurrent.futures.as_completed(futures):
future.result()
因为future.result()会在发生异常时重新引发异常。
如果您想退出整个Python流程，则可以放弃os._exit(0)，但这可能意味着您需要重构。
在Python 3.6.7，Ubuntu 18.04上进行了测试。
答案 8 :(得分：2)
作为线程的诺言，我花了很长时间才了解如何实现Mateusz Kobos的代码（上图）。这是一个澄清的版本，以帮助了解如何使用它。
#!/usr/bin/env python
import sys
import threading
import Queue
class ExThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.__status_queue = Queue.Queue()
def run_with_exception(self):
"""This method should be overriden."""
raise NotImplementedError
def run(self):
"""This method should NOT be overriden."""
try:
self.run_with_exception()
except Exception:
self.__status_queue.put(sys.exc_info())
self.__status_queue.put(None)
def wait_for_exc_info(self):
return self.__status_queue.get()
def join_with_exception(self):
ex_info = self.wait_for_exc_info()
if ex_info is None:
return
else:
raise ex_info[1]
class MyException(Exception):
pass
class MyThread(ExThread):
def __init__(self):
ExThread.__init__(self)
# This overrides the "run_with_exception" from class "ExThread"
# Note, this is where the actual thread to be run lives. The thread
# to be run could also call a method or be passed in as an object
def run_with_exception(self):
# Code will function until the int
print "sleeping 5 seconds"
import time
for i in 1, 2, 3, 4, 5:
print i
time.sleep(1)
# Thread should break here
int("str")
# I'm honestly not sure why these appear here? So, I removed them.
# Perhaps Mateusz can clarify?
# thread_name = threading.current_thread().name
# raise MyException("An error in thread '{}'.".format(thread_name))
if __name__ == '__main__':
# The code lives in MyThread in this example. So creating the MyThread
# object set the code to be run (but does not start it yet)
t = MyThread()
# This actually starts the thread
t.start()
print
print ("Notice 't.start()' is considered to have completed, although"
" the countdown continues in its new thread. So you code "
"can tinue into new processing.")
# Now that the thread is running, the join allows for monitoring of it
try:
t.join_with_exception()
# should be able to be replace "Exception" with specific error (untested)
except Exception, e:
print
print "Exceptioon was caught and control passed back to the main thread"
print "Do some handling here...or raise a custom exception "
thread_name = threading.current_thread().name
e = ("Caught a MyException in thread: '" +
str(thread_name) +
"' [" + str(e) + "]")
raise Exception(e) # Or custom class of exception, such as MyException
答案 9 :(得分：1)
类似于RickardSjogren没有Queue，sys等但也没有一些侦听器的信号：直接执行一个对应于except块的异常处理程序。
#!/usr/bin/env python3
import threading
class ExceptionThread(threading.Thread):
def __init__(self, callback=None, *args, **kwargs):
"""
Redirect exceptions of thread to an exception handler.
:param callback: function to handle occured exception
:type callback: function(thread, exception)
:param args: arguments for threading.Thread()
:type args: tuple
:param kwargs: keyword arguments for threading.Thread()
:type kwargs: dict
"""
self._callback = callback
super().__init__(*args, **kwargs)
def run(self):
try:
if self._target:
self._target(*self._args, **self._kwargs)
except BaseException as e:
if self._callback is None:
raise e
else:
self._callback(self, e)
finally:
# Avoid a refcycle if the thread is running a function with
# an argument that has a member that points to the thread.
del self._target, self._args, self._kwargs, self._callback
只有self._callback和run（）中的except块是普通线程的补充。线程。
答案 10 :(得分：1)
我知道我在这里参加聚会有点晚了，但是我遇到了一个非常相似的问题，但是其中包括使用tkinter作为GUI，并且mainloop使得无法使用任何依赖于.join（ ）。因此，我改编了原始问题的EDIT中给出的解决方案，但使其变得更笼统，以便于他人理解。
这是正在使用的新线程类：
import threading
import traceback
import logging
class ExceptionThread(threading.Thread):
def __init__(self, *args, **kwargs):
threading.Thread.__init__(self, *args, **kwargs)
def run(self):
try:
if self._target:
self._target(*self._args, **self._kwargs)
except Exception:
logging.error(traceback.format_exc())
def test_function_1(input):
raise IndexError(input)
if __name__ == "__main__":
input = 'useful'
t1 = ExceptionThread(target=test_function_1, args=[input])
t1.start()
当然，您总是可以通过其他方式（例如将其打印出来或将其输出到控制台）以其他方式处理异常。
这使您可以像完全使用Thread类一样使用ExceptionThread类，而无需进行任何特殊修改。
答案 11 :(得分：1)
我正在做的是，简单的覆盖线程的连接和运行方法：
class RaisingThread(threading.Thread):
def run(self):
self._exc = None
try:
super().run()
except Exception as e:
self._exc = e
def join(self):
super().join()
if self._exc:
raise self._exc
用法如下：
def foo():
time.sleep(2)
print('hi, from foo!')
raise Exception('exception from foo')
t = RaisingThread(target=foo)
t.start()
try:
t.join()
except Exception as e:
print(e)
结果：
hi, from foo!
exception from foo!
答案 12 :(得分：0)
我喜欢的一种方法是基于observer pattern。我定义了一个信号类，我的线程用它来向侦听器发出异常。它还可以用于从线程返回值。例如：
import threading
class Signal:
def __init__(self):
self._subscribers = list()
def emit(self, *args, **kwargs):
for func in self._subscribers:
func(*args, **kwargs)
def connect(self, func):
self._subscribers.append(func)
def disconnect(self, func):
try:
self._subscribers.remove(func)
except ValueError:
raise ValueError('Function {0} not removed from {1}'.format(func, self))
class WorkerThread(threading.Thread):
def __init__(self, *args, **kwargs):
super(WorkerThread, self).__init__(*args, **kwargs)
self.Exception = Signal()
self.Result = Signal()
def run(self):
if self._Thread__target is not None:
try:
self._return_value = self._Thread__target(*self._Thread__args, **self._Thread__kwargs)
except Exception as e:
self.Exception.emit(e)
else:
self.Result.emit(self._return_value)
if __name__ == '__main__':
import time
def handle_exception(exc):
print exc.message
def handle_result(res):
print res
def a():
time.sleep(1)
raise IOError('a failed')
def b():
time.sleep(2)
return 'b returns'
t = WorkerThread(target=a)
t2 = WorkerThread(target=b)
t.Exception.connect(handle_exception)
t2.Result.connect(handle_result)
t.start()
t2.start()
print 'Threads started'
t.join()
t2.join()
print 'Done'
我没有足够的经验来处理线程声称这是一种完全安全的方法。但它对我有用，我喜欢灵活性。
答案 13 :(得分：0)
使用赤裸裸的异常并不是一个好习惯，因为你通常会比你讨价还价更多。
我建议修改except以仅捕获您想要处理的异常。我不认为提高它会产生预期的效果，因为当您在外部TheThread中实例化try时，如果它引发异常，则分配永远不会发生。
相反，您可能只想提醒它并继续前进，例如：
def run(self):
try:
shul.copytree(self.sourceFolder, self.destFolder)
except OSError, err:
print err
然后当捕获到该异常时，您可以在那里处理它。然后当外部try从TheThread中捕获异常时，您知道它不会是您已经处理的异常，并且会帮助您隔离您的流程。
答案 14 :(得分：0)
捕获线程异常并与调用方法进行通信的简单方法可以是将字典或列表传递给worker方法。
示例（将字典传递给worker方法）：
import threading
def my_method(throw_me):
raise Exception(throw_me)
def worker(shared_obj, *args, **kwargs):
try:
shared_obj['target'](*args, **kwargs)
except Exception as err:
shared_obj['err'] = err
shared_obj = {'err':'', 'target': my_method}
throw_me = "Test"
th = threading.Thread(target=worker, args=(shared_obj, throw_me), kwargs={})
th.start()
th.join()
if shared_obj['err']:
print(">>%s" % shared_obj['err'])
答案 15 :(得分：0)
使用异常存储包装线程。
import threading
import sys
class ExcThread(threading.Thread):
def __init__(self, target, args = None):
self.args = args if args else []
self.target = target
self.exc = None
threading.Thread.__init__(self)
def run(self):
try:
self.target(*self.args)
raise Exception('An error occured here.')
except Exception:
self.exc=sys.exc_info()
def main():
def hello(name):
print(!"Hello, {name}!")
thread_obj = ExcThread(target=hello, args=("Jack"))
thread_obj.start()
thread_obj.join()
exc = thread_obj.exc
if exc:
exc_type, exc_obj, exc_trace = exc
print(exc_type, ':',exc_obj, ":", exc_trace)
main()
答案 16 :(得分：0)
pygolang提供了sync.WorkGroup，它尤其将异常从生成的工作线程传播到主线程。例如：
#!/usr/bin/env python
"""This program demostrates how with sync.WorkGroup an exception raised in
spawned thread is propagated into main thread which spawned the worker."""
from __future__ import print_function
from golang import sync, context
def T1(ctx, *argv):
print('T1: run ... %r' % (argv,))
raise RuntimeError('T1: problem')
def T2(ctx):
print('T2: ran ok')
def main():
wg = sync.WorkGroup(context.background())
wg.go(T1, [1,2,3])
wg.go(T2)
try:
wg.wait()
except Exception as e:
print('Tmain: caught exception: %r\n' %e)
# reraising to see full traceback
raise
if __name__ == '__main__':
main()
在运行时提供以下信息：
T1: run ... ([1, 2, 3],)
T2: ran ok
Tmain: caught exception: RuntimeError('T1: problem',)
Traceback (most recent call last):
File "./x.py", line 28, in <module>
main()
File "./x.py", line 21, in main
wg.wait()
File "golang/_sync.pyx", line 198, in golang._sync.PyWorkGroup.wait
pyerr_reraise(pyerr)
File "golang/_sync.pyx", line 178, in golang._sync.PyWorkGroup.go.pyrunf
f(pywg._pyctx, *argv, **kw)
File "./x.py", line 10, in T1
raise RuntimeError('T1: problem')
RuntimeError: T1: problem
问题的原始代码就是：
wg = sync.WorkGroup(context.background())
def _(ctx):
shul.copytree(sourceFolder, destFolder)
wg.go(_)
# waits for spawned worker to complete and, on error, reraises
# its exception on the main thread.
wg.wait()
答案 17 :(得分：0)
我认为其他解决方案有点复杂，如果您唯一想要的是实际看到某个地方的异常，而不是无视和完全盲目。
解决方案是创建一个自定义 Thread，从主线程获取记录器并记录所有异常。
class ThreadWithLoggedException(threading.Thread):
"""
Similar to Thread but will log exceptions to passed logger.
Args:
logger: Logger instance used to log any exception in child thread
Exception is also reachable via <thread>.exception from the main thread.
"""
def __init__(self, *args, **kwargs):
try:
self.logger = kwargs.pop("logger")
except KeyError:
raise Exception("Missing 'logger' in kwargs")
super().__init__(*args, **kwargs)
self.exception = None
def run(self):
try:
if self._target is not None:
self._target(*self._args, **self._kwargs)
except Exception as exception:
thread = threading.current_thread()
self.exception = exception
self.logger.exception(f"Exception in child thread {thread}: {exception}")
finally:
del self._target, self._args, self._kwargs
示例：
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(logging.StreamHandler())
def serve():
raise Exception("Earth exploded.")
th = ThreadWithLoggedException(target=serve, logger=logger)
th.start()
主线程输出：
Exception in child thread <ThreadWithLoggedException(Thread-1, started 139922384414464)>: Earth exploded.
Traceback (most recent call last):
File "/core/utils.py", line 108, in run
self._target(*self._args, **self._kwargs)
File "/myapp.py", line 105, in serve
raise Exception("Earth exploded.")
Exception: Earth exploded.
答案 18 :(得分：0)
我使用这个版本，它是最小的并且运行良好。
class SafeThread(threading.Thread):
def __init__(self, *args, **kwargs):
super(SafeThread, self).__init__(*args, **kwargs)
self.exception = None
def run(self) -> None:
try:
super(SafeThread, self).run()
except Exception as ex:
self.exception = ex
traceback.print_exc()
def join(self, *args, **kwargs) -> None:
super(SafeThread, self).join(*args, **kwargs)
if self.exception:
raise self.exception
要使用它，只需将 threading.Thread 替换为 SafeThread，例如
t = SafeThread(target = some_function, args = (some, args,))
t.start()
# do something else here if you want as the thread runs in the background
t.join()