如何在 Python 中分析多线程程序？

Question

我正在用 Python 开发一个本质上的多线程模块，我想知道它把时间花在哪里了。 cProfile 似乎只分析主线程。 有没有办法分析计算中涉及的所有线程？

Answer 1

查看 Dask 项目中的 mtprof：

https://github.com/dask/mtprof

它是 cProfile 的直接替代品，如果您的线程以通常的方式启动并在主线程之前完成，则会将其统计数据汇总到相同的报告统计数据中。 对我来说就像一个魅力。

Answer 2

从 2019 年开始：我喜欢 vartec 的建议，但真的很喜欢代码示例。 因此我建立了一个 - 实施起来并不困难，但你确实需要考虑一些事情。 这是一个工作示例（Python 3.6）：

您可以看到结果考虑了 Thread1 和 Thread1 所花费的时间。 thread2 调用 thread_func()。

您需要在代码中进行的唯一更改是子类化 threading.Thread，重写其 run() 方法。 只需进行最少的更改即可轻松地分析螺纹。

import threading
import cProfile
from time import sleep
from pstats import Stats
import pstats
from time import time
import threading
import sys

# using different times to ensure the results reflect all threads
SHORT = 0.5
MED = 0.715874
T1_SLEEP = 1.37897
T2_SLEEP = 2.05746
ITER = 1
ITER_T = 4

class MyThreading(threading.Thread):
    """ Subclass to arrange for the profiler to run in the thread """
    def run(self):
        """ Here we simply wrap the call to self._target (the callable passed as arg to MyThreading(target=....) so that cProfile runs it for us, and thus is able to profile it. 
            Since we're in the current instance of each threading object at this point, we can run arbitrary number of threads & profile all of them 
        """
        try:
            if self._target:
                # using the name attr. of our thread to ensure unique profile filenames
                cProfile.runctx('self._target(*self._args, **self._kwargs)', globals=globals(), locals=locals(), filename= f'full_server_thread_{self.name}')
        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

def main(args):
    """ Main func. """
    thread1_done =threading.Event()
    thread1_done.clear()
    thread2_done =threading.Event()
    thread2_done.clear()

    print("Main thread start.... ")
    t1 = MyThreading(target=thread_1, args=(thread1_done,), name="T1" )
    t2 = MyThreading(target=thread_2, args=(thread2_done,), name="T2" )
    print("Subthreads instances.... launching.")

    t1.start()          # start will call our overrident threading.run() method
    t2.start()

    for i in range(0,ITER):
        print(f"MAIN iteration: {i}")
        main_func_SHORT()
        main_func_MED()

    if thread1_done.wait() and thread2_done.wait():
        print("Threads are done now... ")
        return True

def main_func_SHORT():
    """ Func. called by the main T """
    sleep(SHORT)
    return True

def main_func_MED():
    sleep(MED)
    return True


def thread_1(done_flag):
    print("subthread target func 1 ")
    for i in range(0,ITER_T):
        thread_func(T1_SLEEP)
    done_flag.set()

def thread_func(SLEEP):
    print(f"Thread func")
    sleep(SLEEP)

def thread_2(done_flag):
    print("subthread target func 2 ")
    for i in range(0,ITER_T):
        thread_func(T2_SLEEP)
    done_flag.set()

if __name__ == '__main__':

    import sys
    args = sys.argv[1:]
    cProfile.run('main(args)', f'full_server_profile')
    stats = Stats('full_server_profile')
    stats.add('full_server_thread_T1')
    stats.add('full_server_thread_T2')
    stats.sort_stats('filename').print_stats()

Answer 3

我不知道有任何分析应用程序支持 python 的此类功能 - 但您可以编写一个 Trace 类来写入日志文件，在其中放入操作何时开始、何时结束以及操作时间的信息消耗了。

这是解决您问题的简单而快速的解决方案。

Answer 4

请参阅 yappi（另一个 Python 分析器）。

Answer 5

您可以在每个线程中运行单独的 cProfile 实例，然后合并统计信息，而不是运行一个 cProfile。 Stats.add() 自动执行此操作。

Answer 6

如果您愿意做一些额外的工作，您可以编写自己的分析类来实现 profile(self, frame, event, arg)。 每当调用函数时都会调用它，并且您可以相当轻松地设置一个结构来从中收集统计信息。

然后，您可以使用 threading.setprofile 在每个线程上注册该函数。 调用该函数时，您可以使用 threading.currentThread() 来查看它在哪个线程上运行。 更多信息（和准备运行的配方）在这里：

http://code.activestate.com/ Recipes/465831/

http://docs.python.org/库/threading.html#threading.setprofile

Answer 7

鉴于不同线程的主要功能不同，您可以使用 此处。