文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

用一个开源工具实现多线程 Python 程序的可视化

2024-12-03 07:23

关注

VizTracer 可以跟踪并发的 Python 程序,以帮助记录、调试和剖析。

并发是现代编程中必不可少的一部分,因为我们有多个核心,有许多需要协作的任务。然而,当并发程序不按顺序运行时,就很难理解它们。对于工程师来说,在这些程序中发现 bug 和性能问题不像在单线程、单任务程序中那么容易。

在 Python 中,你有多种并发的选择。最常见的可能是用 threading 模块的多线程,用subprocess 和 multiprocessing 模块的多进程,以及最近用 asyncio 模块提供的 async 语法。在 VizTracer 之前,缺乏分析使用了这些技术程序的工具。

VizTracer 是一个追踪和可视化 Python 程序的工具,对日志、调试和剖析很有帮助。尽管它对单线程、单任务程序很好用,但它在并发程序中的实用性是它的独特之处。

尝试一个简单的任务

从一个简单的练习任务开始:计算出一个数组中的整数是否是质数并返回一个布尔数组。下面是一个简单的解决方案:

  1. def is_prime(n):
  2. for i in range(2, n):
  3. if n % i == 0:
  4. return False
  5. return True
  6.  
  7. def get_prime_arr(arr):
  8. return [is_prime(elem) for elem in arr]

试着用 VizTracer 以单线程方式正常运行它:

  1. if __name__ == "__main__":
  2. num_arr = [random.randint(100, 10000) for _ in range(6000)]
  3. get_prime_arr(num_arr)
  1. viztracer my_program.py

 

Running code in a single thread

调用堆栈报告显示,耗时约 140ms,大部分时间花在 get_prime_arr 上。

 

call-stack report

这只是在数组中的元素上一遍又一遍地执行 is_prime 函数。

这是你所期望的,而且它并不有趣(如果你了解 VizTracer 的话)。

试试多线程程序

试着用多线程程序来做:

  1. if __name__ == "__main__":
  2.     num_arr = [random.randint(100, 10000) for i in range(2000)]
  3.     thread1 = Thread(target=get_prime_arr, args=(num_arr,))
  4.     thread2 = Thread(target=get_prime_arr, args=(num_arr,))
  5.     thread3 = Thread(target=get_prime_arr, args=(num_arr,))
  6.  
  7.     thread1.start()
  8.     thread2.start()
  9.     thread3.start()
  10.  
  11.     thread1.join()
  12.     thread2.join()
  13.     thread3.join()

为了配合单线程程序的工作负载,这就为三个线程使用了一个 2000 元素的数组,模拟了三个线程共享任务的情况。

 

Multi-thread program

如果你熟悉 Python 的全局解释器锁(GIL),就会想到,它不会再快了。由于开销太大,花了 140ms 多一点的时间。不过,你可以观察到多线程的并发性:

 

Concurrency of multiple threads

当一个线程在工作(执行多个 is_prime 函数)时,另一个线程被冻结了(一个 is_prime 函数);后来,它们进行了切换。这是由于 GIL 的原因,这也是 Python 没有真正的多线程的原因。它可以实现并发,但不能实现并行。

用多进程试试

要想实现并行,办法就是 multiprocessing 库。下面是另一个使用 multiprocessing 的版本:

  1. if __name__ == "__main__":
  2.     num_arr = [random.randint(100, 10000) for _ in range(2000)]
  3.    
  4.     p1 = Process(target=get_prime_arr, args=(num_arr,))
  5.     p2 = Process(target=get_prime_arr, args=(num_arr,))
  6.     p3 = Process(target=get_prime_arr, args=(num_arr,))
  7.  
  8.     p1.start()
  9.     p2.start()
  10.     p3.start()
  11.  
  12.     p1.join()
  13.     p2.join()
  14.     p3.join()

要使用 VizTracer 运行它,你需要一个额外的参数:

  1. viztracer --log_multiprocess my_program.py

 

Running with extra argument

整个程序在 50ms 多一点的时间内完成,实际任务在 50ms 之前完成。程序的速度大概提高了三倍。

为了和多线程版本进行比较,这里是多进程版本:

 

Multi-process version

在没有 GIL 的情况下,多个进程可以实现并行,也就是多个 is_prime 函数可以并行执行。

不过,Python 的多线程也不是一无是处。例如,对于计算密集型和 I/O 密集型程序,你可以用睡眠来伪造一个 I/O 绑定的任务:

  1. def io_task():
  2.     time.sleep(0.01)

在单线程、单任务程序中试试:

  1. if __name__ == "__main__":
  2.     for _ in range(3):
  3.         io_task()

 

I/O-bound single-thread, single-task program

整个程序用了 30ms 左右,没什么特别的。

现在使用多线程:

  1. if __name__ == "__main__":
  2.     thread1 = Thread(target=io_task)
  3.     thread2 = Thread(target=io_task)
  4.     thread3 = Thread(target=io_task)
  5.  
  6.     thread1.start()
  7.     thread2.start()
  8.     thread3.start()
  9.  
  10.     thread1.join()
  11.     thread2.join()
  12.     thread3.join()

 

I/O-bound multi-thread program

程序耗时 10ms,很明显三个线程是并发工作的,这提高了整体性能。

用 asyncio 试试

Python 正在尝试引入另一个有趣的功能,叫做异步编程。你可以制作一个异步版的任务:

  1. import asyncio
  2.  
  3. async def io_task():
  4.     await asyncio.sleep(0.01)
  5.  
  6. async def main():
  7.     t1 = asyncio.create_task(io_task())
  8.     t2 = asyncio.create_task(io_task())
  9.     t3 = asyncio.create_task(io_task())
  10.  
  11.     await t1
  12.     await t2
  13.     await t3
  14.  
  15. if __name__ == "__main__":
  16.     asyncio.run(main())

由于 asyncio 从字面上看是一个带有任务的单线程调度器,你可以直接在它上使用 VizTracer:

 

VizTracer with asyncio

依然花了 10ms,但显示的大部分函数都是底层结构,这可能不是用户感兴趣的。为了解决这个问题,可以使用 --log_async 来分离真正的任务:

  1. viztracer --log_async my_program.py

 

Using --log_async to separate tasks

现在,用户任务更加清晰了。在大部分时间里,没有任务在运行(因为它唯一做的事情就是睡觉)。有趣的部分是这里:

 

Graph of task creation and execution

这显示了任务的创建和执行时间。Task-1 是 main() 协程,创建了其他任务。Task-2、Task-3、Task-4 执行 io_task 和 sleep 然后等待唤醒。如图所示,因为是单线程程序,所以任务之间没有重叠,VizTracer 这样可视化是为了让它更容易理解。

为了让它更有趣,可以在任务中添加一个 time.sleep 的调用来阻止异步循环:

  1. async def io_task():
  2.     time.sleep(0.01)
  3.     await asyncio.sleep(0.01)

 

time.sleep call

程序耗时更长(40ms),任务填补了异步调度器中的空白。

这个功能对于诊断异步程序的行为和性能问题非常有帮助。

看看 VizTracer 发生了什么?

通过 VizTracer,你可以在时间轴上查看程序的进展情况,而不是从复杂的日志中想象。这有助于你更好地理解你的并发程序。

VizTracer 是开源的,在 Apache 2.0 许可证下发布,支持所有常见的操作系统(Linux、macOS 和 Windows)。你可以在 VizTracer 的 GitHub 仓库中了解更多关于它的功能和访问它的源代码。

 

来源:Linux中国内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯