深度解析Python性能优化与GIL的那些事20240918

Narutolxy

已于 2024-09-18 11:14:38 修改

阅读量507

点赞数 16

分类专栏：技术干货分享 Python笔记文章标签： python 性能优化开发语言

于 2024-09-18 11:14:24 首次发布

本文链接：https://blog.csdn.net/Narutolxy/article/details/142328323

版权

技术干货分享同时被 2 个专栏收录

49 篇文章 0 订阅

订阅专栏

Python笔记

38 篇文章 1 订阅

订阅专栏

深度解析Python性能优化与GIL的那些事

在Python的世界中，性能优化一直是开发者关注的焦点之一。本文将深入探讨Python的GIL（全局解释器锁），了解其对多线程的影响，以及如何利用各种工具和方法进行性能分析与优化。

引言

Python以其简单易用的特性赢得了众多开发者的青睐。然而，在性能和多线程方面，Python却常常被诟病。究其原因，GIL扮演了关键角色。那么，GIL究竟是什么？它如何影响我们的程序性能？又该如何优化？本文将为您一一揭晓。

什么是GIL？

GIL是CPython本身自带的机制吗？

是的，GIL是CPython解释器的内置机制，并非人为额外添加的。GIL（Global Interpreter Lock，全局解释器锁）是CPython为保证线程安全而引入的一种锁机制。它确保在任何时候，都只有一个线程在执行Python的字节码。

GIL的由来

设计初衷：早期的CPython解释器采用引用计数来管理内存，而引用计数的增减操作需要是线程安全的。为了避免在对象的引用计数上加锁（这会导致性能下降），CPython选择了更为简单的方式，即引入GIL。
内存管理的考虑：由于CPython的内存管理和垃圾回收机制并不是线程安全的，因此需要一种机制来防止多个线程同时执行字节码，导致内存访问冲突和数据不一致。

GIL的作用

线程同步：GIL使得CPython解释器在同一时刻只执行一个线程的字节码，防止了多线程同时访问和修改对象，保证了解释器级别的线程安全。
影响多核利用：由于GIL的存在，即使在多核CPU上，CPython的多线程程序也无法实现真正的并行执行，限制了CPU密集型程序的性能。

深入理解字节码操作

在Python中，源代码会被编译成字节码，然后由解释器执行。理解字节码操作有助于我们深入了解Python的执行过程，以及GIL对线程执行的影响。

什么是字节码？

字节码是Python代码被编译后的中间表示形式，是一种与平台无关的二进制指令集。Python的虚拟机（解释器）逐条读取并执行这些字节码指令。

使用`dis`模块分析字节码

import dis

def example_function(a):
    a += 1
    return a

dis.dis(example_function)

输出：

  2           0 LOAD_FAST                0 (a)
              2 LOAD_CONST               1 (1)
              4 INPLACE_ADD
              6 STORE_FAST               0 (a)

  3           8 LOAD_FAST                0 (a)
             10 RETURN_VALUE

解释：

LOAD_FAST 0 (a)：将变量a加载到栈顶。
LOAD_CONST 1 (1)：将常量1加载到栈顶。
INPLACE_ADD：对栈顶的两个值执行就地加法，并将结果放回栈顶。
STORE_FAST 0 (a)：将栈顶的值存储回变量a。
LOAD_FAST 0 (a)：再次将变量a加载到栈顶，以准备返回。
RETURN_VALUE：返回栈顶的值。

从字节码可以看出，a += 1并非一个原子操作，而是由多条指令组成。这意味着在执行这些指令的过程中，可能发生线程切换，导致线程安全问题。

GIL对多线程的影响

CPU密集型任务

对于需要大量计算的CPU密集型任务，由于GIL的存在，同一时间只能有一个线程执行Python字节码，导致无法充分利用多核CPU的优势。

I/O密集型任务

对于I/O密集型任务（如文件读写、网络请求），Python在进行I/O操作时会释放GIL，允许其他线程执行。因此，GIL对I/O密集型任务的影响较小，可以通过多线程提高程序的并发性能。

为什么有了GIL，还要关注线程安全？

**GIL并不能保证我们编写的代码都是线程安全的。**虽然GIL确保了同一时刻只有一个线程执行Python字节码，但在执行多条字节码指令的过程中，可能发生线程切换，导致数据竞争。

原子性操作的定义

原子操作是指在执行过程中不可被中断的操作，要么全部执行完毕，要么完全不执行。对于Python的一些简单操作，可能对应单个字节码指令，是原子的。但更多的操作是由多条字节码指令组成的，可能在指令之间被其他线程打断。

示例：线程不安全的操作

import threading

n = [0]

def increment():
    n[0] += 1

threads = []

for _ in range(10000):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(n[0])

预期结果：n[0]应该等于10000。

**实际结果：**可能小于10000，例如9998。

原因分析：

n[0] += 1并非原子操作，而是由以下步骤组成：

读取n[0]的值（LOAD）。
将其与1相加（ADD）。
将结果写回n[0]（STORE）。

在执行这三个步骤的过程中，可能发生线程切换。例如：

线程A读取了n[0]的值为100。
线程A计算100 + 1 = 101。
线程切换到线程B。
线程B读取了n[0]的值（仍为100）。
线程B计算100 + 1 = 101。
线程A将结果101写回n[0]。
线程B将结果101写回n[0]。

结果，n[0]只增加了一次，导致计数丢失。

使用`dis`模块分析操作

import dis

def increment():
    n[0] += 1

dis.dis(increment)

输出的字节码：

  2           0 LOAD_GLOBAL              0 (n)
              2 LOAD_CONST               1 (0)
              4 DUP_TOP_TWO
              6 BINARY_SUBSCR
              8 LOAD_CONST               2 (1)
             10 INPLACE_ADD
             12 ROT_THREE
             14 STORE_SUBSCR
             16 LOAD_CONST               0 (None)
             18 RETURN_VALUE

解释：

该操作并非单一的原子操作，而是由多条字节码指令组成。
在执行过程中，可能在任意字节码指令之间发生线程切换。

解决方法：使用锁确保线程安全

import threading

n = [0]
lock = threading.Lock()

def increment():
    with lock:
        n[0] += 1

threads = []

for _ in range(10000):
    t = threading.Thread(target=increment)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(n[0])

通过在操作前获取锁，可以确保整个操作的原子性，防止线程切换导致的数据竞争。

如何规避GIL的影响

区分任务类型

CPU密集型任务：使用multiprocessing模块创建多进程，充分利用多核CPU。
I/O密集型任务：使用多线程或协程，如asyncio，提高程序的并发性能。

多进程示例

from multiprocessing import Pool

def cpu_bound_task(n):
    # 计算密集型任务
    return sum(i * i for i in range(n))

if __name__ == '__main__':
    with Pool() as pool:
        results = pool.map(cpu_bound_task, [1000000] * 10)

协程示例

import asyncio

async def io_bound_task():
    # I/O密集型任务
    await asyncio.sleep(1)

async def main():
    tasks = [io_bound_task() for _ in range(100)]
    await asyncio.gather(*tasks)

asyncio.run(main())

如何分析程序性能

二八定律

根据二八定律，程序中80%的性能问题源自20%的代码。因此，找出性能瓶颈是优化的关键。

使用Profiling工具

内置工具：profile、cProfile。
第三方工具：line_profiler、pyflame。

示例：使用`cProfile`

import cProfile

def main():
    # 主函数
    pass

if __name__ == '__main__':
    cProfile.run('main()')

假设我们有以下脚本pycls_3_5_gil.py：

import cProfile

def main():
    pass  # 主函数逻辑

if __name__ == '__main__':
    cProfile.run('main()')

运行结果：

D:\Python38-64\python.exe D:/git_new_src/KidsTutorAndEfficiencyScripts/interview_python/pycls_3_5_gil.py
         4 function calls in 0.000 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.000    0.000 <string>:1(<module>)
        1    0.000    0.000    0.000    0.000 pycls_3_5_gil.py:97(main)
        1    0.000    0.000    0.000    0.000 {built-in method builtins.exec}
        1    0.000    0.000    0.000    0.000 {method 'disable' of '_lsprof.Profiler' objects}

进程已结束,退出代码0

解释：

ncalls：函数被调用的次数。
tottime：函数自身的运行时间，不包括调用子函数的时间。
percall：tottime除以调用次数，即平均每次调用的时间。
cumtime：函数运行的总时间，包括所有子函数的运行时间。
percall：cumtime除以调用次数，即平均每次调用的总时间。
filename:lineno(function)：函数所在的文件、行号和名称。

在这个简单的示例中，我们可以看到main函数被调用了一次，运行时间几乎为零。这是因为main函数中并没有实际的逻辑。如果在main函数中添加实际的代码，那么cProfile将提供更详细的性能数据，帮助我们定位性能瓶颈。

更复杂的示例

假设我们在main函数中添加一些逻辑：

def main():
    total = 0
    for i in range(100000):
        total += i
    print(total)

再次运行cProfile，将得到类似如下的输出：

         100004 function calls in 0.012 seconds

   Ordered by: standard name

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.005    0.005    0.012    0.012 <string>:1(<module>)
        1    0.007    0.007    0.007    0.007 pycls_3_5_gil.py:97(main)
        ...

现在，我们可以看到main函数的运行时间，以及循环内部的性能消耗。

火焰图分析

火焰图是一种可视化工具，用于展示程序在运行期间的CPU或内存消耗情况。通过火焰图，我们可以直观地看到函数调用的层次结构和性能消耗。

使用`pyflame`生成火焰图

pyflame是Uber开源的一个性能分析工具，可以为Python程序生成火焰图。

步骤：

安装pyflame和flamegraph工具：
- pyflame需要在Linux系统上编译安装，具体请参考pyflame的GitHub页面。
- flamegraph是一个Perl脚本，用于生成火焰图，下载地址：FlameGraph。
运行程序并收集数据：
```
pyflame -o profile.txt -t python your_script.py
```
这将生成一个包含采样数据的profile.txt文件。
生成火焰图：
```
cat profile.txt | ./flamegraph.pl > flamegraph.svg
```
这将生成一个可视化的火焰图文件flamegraph.svg。

解释火焰图

水平轴（X轴）：表示调用栈的快照，宽度表示该函数被调用的频率或消耗的时间。
垂直轴（Y轴）：表示调用栈的深度，越高表示调用关系越深。
每个矩形块：表示一个函数调用，块的宽度与其耗时成正比。

通过火焰图，我们可以：

直观地找到耗时最多的函数或代码路径。
分析调用关系，了解性能瓶颈所在。
优化关键路径，提升程序性能。

简单示例

假设我们有以下脚本performance_test.py：

import time

def func_a():
    time.sleep(0.1)

def func_b():
    time.sleep(0.2)

def main():
    for _ in range(5):
        func_a()
        func_b()

if __name__ == '__main__':
    main()

生成火焰图：

运行采样：

pyflame -o profile.txt -t python performance_test.py

生成火焰图：

cat profile.txt | ./flamegraph.pl > flamegraph.svg

分析火焰图：

func_b的矩形块比func_a宽，表示func_b消耗的时间更多。
总体来看，程序的大部分时间消耗在time.sleep函数中。

通过火焰图，我们可以直观地看到程序的性能分布，进而进行有针对性的优化。

Python Web服务性能优化

语言并非瓶颈

在Web应用中，性能瓶颈往往不在于语言本身，而在于数据库、网络I/O等环节。

优化策略

数据结构和算法优化：选择合适的数据结构，优化算法，提高代码效率。
数据库优化：
- 建立合理的索引。
- 消除慢查询。
- 使用批量操作，减少数据库I/O。
- 引入NoSQL数据库，满足特定需求。
网络I/O优化：
- 使用批量请求。
- 采用Pipeline技术，减少网络往返次数。
缓存机制：
- 使用Redis或Memcached等内存数据库，缓存热点数据。
异步框架和库：
- 使用asyncio构建异步I/O。
- 采用celery进行任务异步处理。
并发工具：
- 利用gevent实现协程。
- 在I/O密集型任务中使用多线程。

结论

GIL是CPython解释器的内置机制，旨在简化内存管理，保证解释器级别的线程安全。然而，它也限制了多线程的并发性能。通过深入理解GIL的工作原理，了解Python字节码的执行过程，我们可以在编写多线程程序时，注意线程安全问题，使用合适的同步机制。

同时，结合任务类型选择合适的并发模型，利用多进程、协程等方式规避GIL的影响，以及使用各种性能分析工具（如cProfile、火焰图）对程序进行分析，我们可以有效地优化Python程序的性能，提升应用的效率和响应速度。

Narutolxy

关注

16
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

深度解析Python性能优化与GIL的那些事20240918

深度解析Python性能优化与GIL的那些事

引言

什么是GIL？

GIL是CPython本身自带的机制吗？

GIL的由来

GIL的作用

深入理解字节码操作

什么是字节码？

使用dis模块分析字节码

GIL对多线程的影响

CPU密集型任务

I/O密集型任务

为什么有了GIL，还要关注线程安全？

原子性操作的定义

示例：线程不安全的操作

使用dis模块分析操作

解决方法：使用锁确保线程安全

如何规避GIL的影响

区分任务类型

多进程示例

协程示例

如何分析程序性能

二八定律

使用Profiling工具

示例：使用cProfile

更复杂的示例

火焰图分析

使用pyflame生成火焰图

解释火焰图

简单示例

Python Web服务性能优化

语言并非瓶颈

优化策略

结论

使用`dis`模块分析字节码

使用`dis`模块分析操作

示例：使用`cProfile`

使用`pyflame`生成火焰图