用python进行多线程跑多个程序，如何抓取程序异常中断后的Stack trace

Big-Man

如图，我用python的多线程同时运行多个程序，但是有的程序会出现异常crash掉，crash后会在屏幕上打印出错的stack trace，但是这些crash后的信息无法在tee出去的到og中，怎么样才能获取到异常中断后的stack trace信息呢

isdkz

在Python中，可以使用 sys.excepthook 来捕获异常并获取堆栈跟踪信息。以下是一个示例代码，演示如何在多线程中捕获异常并获取堆栈跟踪信息：

1. import sys
   
2. import traceback
   
3. from threading import Thread
   
4. 
   
5. def handle_exception(exc_type, exc_value, exc_traceback):
   
6.     # 获取堆栈跟踪信息
   
7.     stack_trace = traceback.format_exception(exc_type, exc_value, exc_traceback)
   
8.     # 将堆栈跟踪信息输出到日志文件或其他地方
   
9.     with open('error.log', 'a') as f:
   
10.         f.write(''.join(stack_trace))
    
11. 
    
12. # 设置异常处理函数
    
13. sys.excepthook = handle_exception
    
14. 
    
15. # 定义一个线程函数，模拟可能出现异常的代码
    
16. def my_thread_func():
    
17.     try:
    
18.         # 这里是你的代码逻辑
    
19.         # 可能会出现异常的地方
    
20.         raise ValueError('发生了一个异常')
    
21.     except Exception as e:
    
22.         # 在这里捕获异常，以便excepthook能够处理它
    
23.         exc_type, exc_value, exc_traceback = sys.exc_info()
    
24.         sys.excepthook(exc_type, exc_value, exc_traceback)
    
25. 
    
26. # 创建并启动线程
    
27. thread = Thread(target=my_thread_func)
    
28. thread.start()
    

复制代码

在上面的示例中，我们定义了一个 handle_exception 函数来处理异常，并使用 traceback.format_exception 来获取堆栈跟踪信息。然后，我们将堆栈跟踪信息写入到一个日志文件中。

在 my_thread_func 函数中，我们使用 try-except 语句捕获可能出现的异常，并调用 sys.excepthook 来处理异常。这样，即使线程中的代码发生异常并中断，我们仍然能够获取到堆栈跟踪信息。

请根据你的实际需求修改代码中的日志文件路径和异常处理逻辑。

Mike_python小

问题：如何在使用Python的多线程运行多个程序时，捕获异常中断后的堆栈跟踪信息？

要获取异常中断后的堆栈跟踪信息，可以使用以下方法：

1. 在每个线程中使用try-except块来捕获异常并打印堆栈跟踪信息。这样可以确保即使线程出现异常也能打印相关信息。
   
  

2.    import traceback
3.    
4.    def run_program():
5.        try:
6.            # 程序逻辑
7.        except Exception as e:
8.            traceback.print_exc()
9.    

复制代码

   
2. 在主线程中等待所有子线程完成，并收集它们的输出。可通过将子线程的输出重定向到主线程来实现。

  

2.    import sys
3.    from threading import Thread
4.    
5.    class MyThread(Thread):
6.        def __init__(self, target):
7.            super().__init__()
8.            self.target = target
9.            self.output = None
10.            
11.        def run(self):
12.            try:
13.                self.output = self.target()
14.            except Exception as e:
15.                self.output = traceback.format_exc()
16.    
17.    def run_program():
18.        # 程序逻辑
19.    
20.    threads = [MyThread(run_program) for _ in range(num_threads)]
21.    for thread in threads:
22.        thread.start()
23.    
24.    for thread in threads:
25.        thread.join()
26.        if thread.output:
27.            sys.stdout.write(thread.output)
28.    

复制代码

这样，在多线程运行多个程序时，无论发生异常还是正常运行，都可以捕获并打印相应的堆栈跟踪信息。

球一个最佳答案谢谢啦！这对我非常重要！

liuhongrun2022

你可以使用 traceback 模块在 Python 中获取异常的 stack trace。当你的线程抛出一个异常时，你可以捕获它并使用 traceback 模块来获取 stack trace。

下面是一个基本的示例，展示了如何在一个线程中捕获异常并打印 stack trace：

1. import threading
2. import traceback
4. def thread_function():
5.     try:
6.         # 这里放你的代码
7.         # 例如，我们故意引发一个异常
8.         raise Exception('An example exception')
9.     except Exception:
10.         print("Exception in thread:")
11.         traceback.print_exc()
13. thread = threading.Thread(target=thread_function)
14. thread.start()
15. thread.join()

复制代码

在这个示例中，我们在 thread_function 内部使用 try/except 语句来捕获任何可能抛出的异常。然后，我们使用 traceback.print_exc() 函数来打印出错的 stack trace。这将把 stack trace 输出到标准错误输出，你可以重定向它到一个文件，或者处理为你所需要的格式。

如果你需要以字符串的形式获取 stack trace，你可以使用 traceback.format_exc() 函数，像这样：

1. import traceback
3. try:
4.     # 你的代码
5.     raise Exception('An example exception')
6. except Exception:
7.     print("Exception in thread:")
8.     print(traceback.format_exc())

复制代码

这将返回一个字符串，你可以把它写入到日志，或者进行其他处理。