【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】2.25 多线程并行：GIL绕过与真正并发

在这里插入图片描述

2.25 多线程并行：GIL绕过与真正并发

2.25.1 NumPy的GIL释放机制

2.25.1.1 GIL简介

Python 的全局解释器锁（Global Interpreter Lock，简称 GIL）是一个互斥锁，用于保护对 Python 对象的访问。GIL 确保在多线程环境中，同一时刻只有一个线程在执行字节码。这在很多情况下是一个性能瓶颈，特别是在多核处理器上。

2.25.1.2 为什么 NumPy 可以绕过 GIL

NumPy 是一个用 C 语言编写的高效数值计算库。NumPy 的底层函数是用 C 语言实现的，可以暂时释放 GIL 以进行高效的计算。这使得 NumPy 在多线程环境中能够实现真正的并行计算。

2.25.1.3 释放 GIL 的原理

NumPy 通过在 C 扩展中暂时释放 GIL 来实现多线程并行。具体步骤如下：

释放 GIL：在 C 扩展函数中，使用 Py_BEGIN_ALLOW_THREADS 和 Py_END_ALLOW_THREADS 宏来释放和重新获取 GIL。
使用多线程库：在释放 GIL 的期间，可以使用多线程库（如 OpenMP）来并行执行计算任务。
重新获取 GIL：完成计算任务后，重新获取 GIL，以确保 Python 解释器的安全性。

2.25.1.4 代码示例

import numpy as np
import threading

def compute_mean(array):
    # 释放 GIL
    np.core._rational.arithmetic._begin_threads()
    
    # 进行计算
    result = np.mean(array)  # 计算数组的均值
    
    # 重新获取 GIL
    np.core._rational.arithmetic._end_threads()
    
    return result

# 创建一个大数组
data = np.random.rand(10000000)

# 创建多个线程
threads = []
for i in range(4):
    thread = threading.Thread(target=compute_mean, args=(data,))
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

print("计算完成")

2.25.1.5 优缺点

优点：
- 提高性能：在多核处理器上，释放 GIL 可以显著提高计算性能。
- 简化开发：NumPy 的高层接口隐藏了多线程的复杂性，使得开发更加简单。
缺点：
- 增加复杂性：在底层释放 GIL 需要对 C 语言有一定的了解。
- 安全性问题：不当的 GIL 操作可能导致数据不一致和竞态条件。

2.25.2 线程池配置与使用

2.25.2.1 线程池简介

线程池（Thread Pool）是一种多线程处理形式，处理过程中将任务添加到队列中，然后在创建线程后自动启动这些任务。线程池可以有效管理和复用线程资源，减少线程创建和销毁的开销。

2.25.2.2 使用 `concurrent.futures` 配置线程池

concurrent.futures 是 Python 标准库中的一个高级线程池接口，使用非常方便。

2.25.2.3 代码示例

import numpy as np
from concurrent.futures import ThreadPoolExecutor

def process_data(data):
    result = np.mean(data)  # 计算数组的均值
    return result

# 创建一个大数组
data = np.random.rand(10000000)

# 将数据分割成多个子数组
sub_arrays = np.array_split(data, 4)

# 配置线程池
with ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(process_data, sub_arrays))

# 计算总均值
total_mean = np.mean(results)  # 计算子数组均值的总均值

print(f"总均值: {total_mean}")

2.25.2.4 优缺点

优点：
- 高效管理：线程池可以高效管理和复用线程资源。
- 简化代码：使用 concurrent.futures 可以简化多线程编程的代码。
缺点：
- 线程数量限制：线程池的线程数量需要合理配置，过多或过少都会影响性能。
- 数据同步问题：线程池中的任务需要谨慎处理数据同步问题。

2.25.3 原子操作与竞态条件

2.25.3.1 原子操作简介

原子操作（Atomic Operation）是指不会被线程调度机制打断的操作；也就是说，这个操作在执行过程中是不可分割的。在多线程编程中，原子操作可以避免竞态条件（Race Condition）。

2.25.3.2 竞态条件示例

import threading

counter = 0

def increment():
    global counter
    for _ in range(1000000):
        counter += 1  # 竞态条件

# 创建多个线程
threads = []
for i in range(4):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

print(f"最终的 counter 值: {counter}")  # 预期值为 4000000，但实际值可能小于预期

2.25.3.3 使用锁解决竞态条件

import threading

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(1000000):
        lock.acquire()  # 获取锁
        counter += 1  # 原子操作
        lock.release()  # 释放锁

# 创建多个线程
threads = []
for i in range(4):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

print(f"最终的 counter 值: {counter}")  # 预期值为 4000000，实际值也为 4000000

2.25.3.4 优缺点

优点：
- 线程安全：使用锁可以确保操作的线程安全性。
- 避免数据不一致：防止竞态条件导致的数据不一致问题。
缺点：
- 性能开销：锁的获取和释放会增加性能开销。
- 死锁风险：不当的锁管理可能导致死锁。

2.25.4 图像批处理案例

2.25.4.1 图像处理简介

图像处理是计算机视觉中的一个重要领域，NumPy 可以高效地处理图像数据。通过多线程并行计算，可以显著提高图像处理的性能。

2.25.4.2 图像批处理步骤

读取图像：使用 PIL 或 OpenCV 读取图像。
图像预处理：将图像数据转换为 NumPy 数组。
多线程处理：使用线程池并行处理多个图像。
结果汇总：将处理结果汇总并保存。

2.25.4.3 代码示例

import numpy as np
from concurrent.futures import ThreadPoolExecutor
from PIL import Image
import os

def load_image(file_path):
    image = Image.open(file_path)  # 读取图像
    return np.array(image)  # 将图像转换为 NumPy 数组

def process_image(image):
    # 进行图像处理，例如滤波
    processed_image = np.array(image, dtype=np.float32)
    processed_image = np.sqrt(processed_image)  # 应用滤波操作
    return processed_image

def save_image(processed_image, output_path):
    processed_image = np.uint8(processed_image)  # 转换为 8 位无符号整数
    Image.fromarray(processed_image).save(output_path)  # 保存处理后的图像

def batch_process_images(input_dir, output_dir, max_workers=4):
    # 获取输入目录中的所有图像文件
    image_files = [os.path.join(input_dir, f) for f in os.listdir(input_dir) if f.endswith('.jpg')]
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 并行加载图像
        images = list(executor.map(load_image, image_files))
        
        # 并行处理图像
        processed_images = list(executor.map(process_image, images))
        
        # 并行保存处理后的图像
        for i, processed_image in enumerate(processed_images):
            output_path = os.path.join(output_dir, f'processed_{i}.jpg')
            executor.submit(save_image, processed_image, output_path)

# 输入和输出目录
input_dir = 'path/to/input/images'
output_dir = 'path/to/output/images'

# 批处理图像
batch_process_images(input_dir, output_dir)

2.25.4.4 注意事项

文件路径：确保输入和输出目录路径正确。
图像格式：处理不同格式的图像时，需要进行相应的格式转换。
内存管理：处理大图像时，注意内存管理，防止内存溢出。

2.25.5 竞态条件调试

2.25.5.1 竞态条件调试工具

threading 模块：Python 标准库中的 threading 模块提供了基本的线程调试工具。
logging 模块：使用 logging 模块记录线程的执行日志，帮助调试。
Valgrind：C/C++ 中的 Valgrind 工具可以帮助检测线程中的内存和数据访问问题。

2.25.5.2 使用 `logging` 调试线程

import threading
import logging

logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')

counter = 0
lock = threading.Lock()

def increment():
    global counter
    for _ in range(1000000):
        lock.acquire()  # 获取锁
        counter += 1  # 原子操作
        lock.release()  # 释放锁
        logging.debug(f"当前 counter 值: {counter}")

# 创建多个线程
threads = []
for i in range(4):
    thread = threading.Thread(target=increment)
    threads.append(thread)
    thread.start()

# 等待所有线程完成
for thread in threads:
    thread.join()

print(f"最终的 counter 值: {counter}")

2.25.5.3 使用 `Valgrind` 调试 C 代码

# 安装 Valgrind
sudo apt-get install valgrind

# 编译 C 代码
gcc -g -o my_program my_program.c

# 运行 Valgrind
valgrind --tool=helgrind ./my_program

2.25.5.4 优缺点

优点：
- 日志记录：使用 logging 可以方便地记录线程的执行情况，帮助定位问题。
- 问题检测：Valgrind 可以检测 C 代码中的线程问题，提高代码的健壮性。
缺点：
- 性能开销：日志记录和 Valgrind 会增加程序的运行开销。
- 复杂性：调试多线程程序需要一定的技巧和经验。

总结

本文详细介绍了如何在 NumPy 中实现多线程并行计算，通过绕过 GIL 实现真正的并发。我们讨论了 NumPy 的 GIL 释放机制、线程池的配置与使用、原子操作与竞态条件的处理，以及图像批处理的案例。最后，我们还介绍了如何调试竞态条件，确保多线程程序的正确性和性能。

通过本文的学习，你将能够更好地理解和应用多线程技术，提升 Python 程序的性能。希望这些内容对你有所帮助！

参考文献

参考资料	链接
NumPy 官方文档	https://numpy.org/doc/stable/
Python 官方文档：threading 模块	https://docs.python.org/3/library/threading.html
Python 官方文档：concurrent.futures 模块	https://docs.python.org/3/library/concurrent.futures.html
Python GIL 讲解	https://realpython.com/python-gil/
OpenMP 官方文档	https://www.openmp.org/specifications/
Valgrind 官方文档	https://valgrind.org/docs/manual/manual.html
Python 多线程优化	https://www.geeksforgeeks.org/multiprocessing-vs-threading-python/
Locks in Python: The Good, the Bad, and the Ugly	https://medium.com/@bfortuner/python-multithreading-vs-multiprocessing-730797d5fbe6
Python 中的线程安全	https://www.toptal.com/python/beyond-threads-a-comprehensive-guide-to-concurrent-python
Image Processing with NumPy	https://scikit-image.org/docs/dev/auto_examples/
图像处理基本原理	https://www.cs.columbia.edu/CAVE/publications/pdfs/Brow09_TIP.pdf
Python 线程池详解	https://www.jianshu.com/p/392f5b6baf44
CPython 解释器源码	https://github.com/python/cpython

这篇文章包含了详细的原理介绍、代码示例、源码注释以及案例等。希望这对您有帮助。如果有任何问题请随私信或评论告诉我。

posted @ 2025-02-04 19:37 爱上编程技术阅读(11) 评论(0) 编辑收藏举报来源

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

· 【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】1.23 数据工厂：高级初始化模式解析

· Python 的多线程与多进程

· python多线程学习记录

阅读排行：
· 分享4款.NET开源、免费、实用的商城系统
· 全程不用写代码，我用AI程序员写了一个飞机大战
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· 白话解读 Dapr 1.15：你的「微服务管家」又秀新绝活了
· 上周热点回顾（2.24-3.2）

公告

昵称：爱上编程技术
园龄： 1个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

爱上编程技术

天天学习

【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】2.25 多线程并行：GIL绕过与真正并发

2.25 多线程并行：GIL绕过与真正并发

目录

2.25.1 NumPy的GIL释放机制

2.25.1.1 GIL简介

2.25.1.2 为什么 NumPy 可以绕过 GIL

2.25.1.3 释放 GIL 的原理

2.25.1.4 代码示例

2.25.1.5 优缺点

2.25.2 线程池配置与使用

2.25.2.1 线程池简介

2.25.2.2 使用 `concurrent.futures` 配置线程池

2.25.2.3 代码示例

2.25.2.4 优缺点

2.25.3 原子操作与竞态条件

2.25.3.1 原子操作简介

2.25.3.2 竞态条件示例

2.25.3.3 使用锁解决竞态条件

2.25.3.4 优缺点

2.25.4 图像批处理案例

2.25.4.1 图像处理简介

2.25.4.2 图像批处理步骤

2.25.4.3 代码示例

2.25.4.4 注意事项

2.25.5 竞态条件调试

2.25.5.1 竞态条件调试工具

2.25.5.2 使用 `logging` 调试线程

2.25.5.3 使用 `Valgrind` 调试 C 代码

2.25.5.4 优缺点

总结

参考文献

公告

搜索

常用链接

我的标签

合集

随笔档案

阅读排行榜

爱上编程技术

天天学习

【Numpy核心编程攻略：Python数据处理、分析详解与科学计算】2.25 多线程并行：GIL绕过与真正并发

2.25 多线程并行：GIL绕过与真正并发

目录

2.25.1 NumPy的GIL释放机制

2.25.1.1 GIL简介

2.25.1.2 为什么 NumPy 可以绕过 GIL

2.25.1.3 释放 GIL 的原理

2.25.1.4 代码示例

2.25.1.5 优缺点

2.25.2 线程池配置与使用

2.25.2.1 线程池简介

2.25.2.2 使用 concurrent.futures 配置线程池

2.25.2.3 代码示例

2.25.2.4 优缺点

2.25.3 原子操作与竞态条件

2.25.3.1 原子操作简介

2.25.3.2 竞态条件示例

2.25.3.3 使用锁解决竞态条件

2.25.3.4 优缺点

2.25.4 图像批处理案例

2.25.4.1 图像处理简介

2.25.4.2 图像批处理步骤

2.25.4.3 代码示例

2.25.4.4 注意事项

2.25.5 竞态条件调试

2.25.5.1 竞态条件调试工具

2.25.5.2 使用 logging 调试线程

2.25.5.3 使用 Valgrind 调试 C 代码

2.25.5.4 优缺点

总结

参考文献

公告

搜索

常用链接

我的标签

合集

随笔档案

阅读排行榜

2.25.2.2 使用 `concurrent.futures` 配置线程池

2.25.5.2 使用 `logging` 调试线程

2.25.5.3 使用 `Valgrind` 调试 C 代码