Python的`GIL`释放：如何通过C扩展或NumPy等库在特定操作中释放`GIL`，提升并发性能。 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

好的，各位朋友，今天我们来聊聊Python的全局解释器锁（GIL）以及如何在特定操作中释放它，从而提升并发性能。GIL的存在是Python并发编程中一个绕不开的话题，理解其工作原理以及规避策略对于编写高性能的Python代码至关重要。

什么是GIL？

全局解释器锁（Global Interpreter Lock，GIL）是CPython解释器中的一个互斥锁，它确保在任何给定时刻，只有一个线程可以执行Python字节码。这意味着即使在多核CPU上，使用标准CPython解释器的多线程Python程序也无法真正地并行执行CPU密集型任务。

为什么需要GIL？

GIL的引入主要是为了简化CPython解释器的内存管理，尤其是对于那些非线程安全的C扩展库。在没有GIL的情况下，多个线程可能同时访问和修改Python对象，导致数据竞争和程序崩溃。 GIL通过强制单线程执行Python字节码，避免了这些问题，提高了CPython解释器的稳定性和易用性。

GIL的影响

GIL对CPU密集型任务的并发性能有显著影响。由于GIL的存在，多线程程序只能在一个核心上执行Python字节码，导致无法充分利用多核CPU的计算能力。对于I/O密集型任务，由于线程通常会在等待I/O操作时释放GIL，因此GIL的影响相对较小。

何时需要考虑GIL？

CPU密集型任务： 如果你的程序主要执行CPU密集型计算，例如数值计算、图像处理、加密解密等，那么GIL可能会成为性能瓶颈。
多线程并发： 如果你的程序使用多线程来并发执行CPU密集型任务，那么你可能会发现性能提升并不明显，甚至不如单线程程序。

如何释放GIL？

虽然GIL是CPython解释器的一个固有特性，但我们仍然可以通过一些方法来释放GIL，从而提升并发性能。主要有以下几种方法：

使用多进程（Multiprocessing）：

multiprocessing 模块允许你创建多个独立的Python进程。每个进程都有自己的Python解释器和GIL，因此可以真正地并行执行CPU密集型任务。

原理： multiprocessing 模块使用操作系统的进程间通信机制（例如管道、共享内存）来实现进程之间的数据共享和同步。
适用场景： 适用于CPU密集型任务，可以充分利用多核CPU的计算能力。
缺点： 进程间的通信开销较大，不适合频繁的数据共享。

import multiprocessing
import time

def cpu_bound_task(n):
    """模拟CPU密集型任务"""
    total = 0
    for i in range(n):
        for j in range(n):
            total += i * j
    return total

def worker(n):
    result = cpu_bound_task(n)
    print(f"Worker process finished with result: {result}")

if __name__ == "__main__":
    start_time = time.time()
    processes = []
    for i in range(multiprocessing.cpu_count()):
        p = multiprocessing.Process(target=worker, args=(500,))  # 调整任务量
        processes.append(p)
        p.start()

    for p in processes:
        p.join()

    end_time = time.time()
    print(f"Total time taken: {end_time - start_time:.2f} seconds")

使用C扩展（C Extensions）：

你可以编写C扩展来执行CPU密集型任务，并在C代码中手动释放GIL。这允许其他Python线程在C扩展执行期间继续执行Python字节码。

原理： C扩展可以直接访问Python的C API，可以手动获取和释放GIL。
适用场景： 适用于需要高性能的CPU密集型任务，例如数值计算、图像处理等。
缺点： 需要编写C代码，增加了开发难度。

// my_extension.c
#include <Python.h>
#include <stdio.h>

static PyObject* long_computation(PyObject* self, PyObject* args) {
    long n;
    if (!PyArg_ParseTuple(args, "l", &n)) {
        return NULL;
    }

    Py_BEGIN_ALLOW_THREADS  // 释放GIL
    long result = 0;
    for (long i = 0; i < n; i++) {
        for (long j = 0; j < n; j++) {
            result += i * j;
        }
    }
    Py_END_ALLOW_THREADS    // 重新获取GIL

    return PyLong_FromLong(result);
}

static PyMethodDef MyExtensionMethods[] = {
    {"long_computation",  long_computation, METH_VARARGS, "Perform a long computation."},
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

static struct PyModuleDef myextensionmodule = {
    PyModuleDef_HEAD_INIT,
    "my_extension",   /* name of module */
    NULL,               /* Module documentation, may be NULL */
    -1,                 /* Size of per-interpreter state or -1 */
    MyExtensionMethods
};

PyMODINIT_FUNC
PyInit_my_extension(void)
{
    return PyModule_Create(&myextensionmodule);
}

# setup.py (用于编译C扩展)
from distutils.core import setup, Extension

module1 = Extension('my_extension',
                    sources = ['my_extension.c'])

setup (name = 'MyExtension',
       version = '1.0',
       description = 'This is a demo package',
       ext_modules = [module1])

编译C扩展：

python setup.py build_ext --inplace

# main.py
import my_extension
import threading
import time

def worker(n):
    start_time = time.time()
    result = my_extension.long_computation(n)
    end_time = time.time()
    print(f"Thread finished with result: {result}, Time taken: {end_time - start_time:.2f} seconds")

if __name__ == "__main__":
    threads = []
    for i in range(4):  # 创建多个线程
        t = threading.Thread(target=worker, args=(500,)) # 调整任务量
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

Py_BEGIN_ALLOW_THREADS 和 Py_END_ALLOW_THREADS: 这两个宏定义是关键。 Py_BEGIN_ALLOW_THREADS 释放 GIL，允许其他 Python 线程执行。 Py_END_ALLOW_THREADS 重新获取 GIL，确保 C 扩展在完成计算后能够安全地访问 Python 对象。

使用NumPy等库释放GIL：

NumPy等库的许多操作都是在C代码中实现的，并且在执行这些操作时会释放GIL。这允许其他Python线程在NumPy计算期间继续执行Python字节码。

原理： NumPy的底层实现使用C语言，并且在执行计算时会释放GIL。
适用场景： 适用于涉及大量数值计算的任务，例如科学计算、数据分析等。
优点： 简单易用，无需编写C代码。
缺点： 并非所有NumPy操作都会释放GIL，需要根据具体情况进行评估。

import numpy as np
import threading
import time

def numpy_operation(size):
    a = np.random.rand(size, size)
    b = np.random.rand(size, size)
    start_time = time.time()
    result = np.dot(a, b)  # 矩阵乘法，会释放GIL
    end_time = time.time()
    print(f"Thread finished, Time taken: {end_time - start_time:.2f} seconds")
    return result

def worker(size):
    numpy_operation(size)

if __name__ == "__main__":
    threads = []
    for i in range(4): # 创建多个线程
        t = threading.Thread(target=worker, args=(500,)) # 调整矩阵大小
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

使用concurrent.futures模块：

concurrent.futures 模块提供了一个高层接口，用于异步执行可调用对象。它可以使用线程池或进程池来执行任务，并且可以自动处理GIL的释放和获取。

原理： concurrent.futures 模块使用线程池或进程池来并发执行任务，可以自动管理GIL的释放和获取。
适用场景： 适用于需要并发执行多个任务的场景，可以简化并发编程的复杂性。
优点： 高层接口，易于使用，可以自动管理GIL。
缺点： 对于CPU密集型任务，使用线程池的性能提升可能有限。

import concurrent.futures
import time

def cpu_bound_task(n):
    """模拟CPU密集型任务"""
    total = 0
    for i in range(n):
        for j in range(n):
            total += i * j
    return total

def worker(n):
    result = cpu_bound_task(n)
    print(f"Worker finished with result: {result}")
    return result

if __name__ == "__main__":
    start_time = time.time()
    with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor: # 使用进程池
        futures = [executor.submit(worker, 500) for _ in range(4)] # 调整任务量

        for future in concurrent.futures.as_completed(futures):
            future.result()

    end_time = time.time()
    print(f"Total time taken: {end_time - start_time:.2f} seconds")

不同方法的比较

方法	原理	适用场景	优点	缺点
多进程 (Multiprocessing)	每个进程有自己的Python解释器和GIL，可以真正并行执行。	CPU密集型任务，需要充分利用多核CPU的计算能力。	充分利用多核CPU，避免GIL的影响。	进程间通信开销较大，不适合频繁的数据共享。
C扩展 (C Extensions)	在C代码中手动释放GIL，允许其他Python线程在C扩展执行期间继续执行。	需要高性能的CPU密集型任务，例如数值计算、图像处理等。	性能高，可以充分利用多核CPU的计算能力。	需要编写C代码，增加了开发难度。
NumPy等库释放GIL	NumPy的底层实现使用C语言，在执行计算时会释放GIL。	涉及大量数值计算的任务，例如科学计算、数据分析等。	简单易用，无需编写C代码。	并非所有NumPy操作都会释放GIL，需要根据具体情况进行评估。
concurrent.futures模块	使用线程池或进程池来并发执行任务，可以自动管理GIL的释放和获取。	需要并发执行多个任务的场景，可以简化并发编程的复杂性。	高层接口，易于使用，可以自动管理GIL。	对于CPU密集型任务，使用线程池的性能提升可能有限。

选择合适的策略

选择哪种方法取决于你的具体应用场景和性能需求。

如果你的程序主要执行CPU密集型任务，并且对性能要求很高，那么使用C扩展可能是最好的选择。
如果你的程序主要执行数值计算任务，并且已经使用了NumPy等库，那么可以利用NumPy的GIL释放机制来提升并发性能。
如果你的程序需要并发执行多个任务，并且对性能要求不是特别高，那么可以使用concurrent.futures模块。
如果你的程序需要充分利用多核CPU的计算能力，并且可以接受进程间通信的开销，那么可以使用multiprocessing模块。

示例：使用C扩展加速图像处理

假设我们有一个图像处理任务，需要对大量像素进行复杂的计算。由于这个任务是CPU密集型的，因此GIL可能会成为性能瓶颈。我们可以使用C扩展来加速这个任务，并在C代码中手动释放GIL。

// image_processing.c
#include <Python.h>
#include <stdio.h>

// 假设这是一个非常耗时的图像处理函数
static void process_pixel(int x, int y, unsigned char* pixel_data) {
    // 模拟复杂的计算
    for (int i = 0; i < 1000; i++) {
        pixel_data[0] = (pixel_data[0] * x + pixel_data[1] * y) % 256;
        pixel_data[1] = (pixel_data[1] * x + pixel_data[2] * y) % 256;
        pixel_data[2] = (pixel_data[2] * x + pixel_data[0] * y) % 256;
    }
}

static PyObject* process_image(PyObject* self, PyObject* args) {
    PyObject* image_data_obj;
    int width, height;

    if (!PyArg_ParseTuple(args, "Oii", &image_data_obj, &width, &height)) {
        return NULL;
    }

    // 将Python字节字符串对象转换为C指针
    char* image_data = PyBytes_AsString(image_data_obj);
    if (image_data == NULL) {
        return NULL;
    }

    Py_BEGIN_ALLOW_THREADS
    // 对图像中的每个像素进行处理
    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            unsigned char* pixel_data = (unsigned char*)(image_data + (y * width + x) * 3); // 假设是RGB图像，每个像素3个字节
            process_pixel(x, y, pixel_data);
        }
    }
    Py_END_ALLOW_THREADS

    Py_RETURN_NONE;
}

static PyMethodDef ImageProcessingMethods[] = {
    {"process_image",  process_image, METH_VARARGS, "Process an image."},
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

static struct PyModuleDef imageprocessingmodule = {
    PyModuleDef_HEAD_INIT,
    "image_processing",   /* name of module */
    NULL,               /* Module documentation, may be NULL */
    -1,                 /* Size of per-interpreter state or -1 */
    ImageProcessingMethods
};

PyMODINIT_FUNC
PyInit_image_processing(void)
{
    return PyModule_Create(&imageprocessingmodule);
}

# setup.py
from distutils.core import setup, Extension

module1 = Extension('image_processing',
                    sources = ['image_processing.c'])

setup (name = 'ImageProcessing',
       version = '1.0',
       description = 'Image processing module',
       ext_modules = [module1])

# main.py
import image_processing
import threading
import time
from PIL import Image  # 确保安装了 Pillow 库： pip install Pillow

def worker(image_data, width, height):
    start_time = time.time()
    image_processing.process_image(image_data, width, height)
    end_time = time.time()
    print(f"Thread finished, Time taken: {end_time - start_time:.2f} seconds")

if __name__ == "__main__":
    # 创建一个示例图像
    width, height = 256, 256
    image = Image.new("RGB", (width, height), "white")
    image_data = image.tobytes() # 获取图像数据的字节字符串

    threads = []
    for i in range(4):
        t = threading.Thread(target=worker, args=(image_data, width, height))
        threads.append(t)
        t.start()

    for t in threads:
        t.join()

总结与反思

Python的GIL虽然限制了CPU密集型任务的多线程并发性能，但是通过多进程、C扩展、NumPy等库，以及concurrent.futures模块，我们仍然可以在一定程度上规避GIL的影响，提升程序的并发性能。选择合适的策略取决于具体的应用场景和性能需求，需要进行仔细的评估和测试。关键在于理解GIL的工作原理，并根据实际情况选择最合适的并发方案。

发表回复 取消回复

发表回复取消回复