Python GIL 绕过：多进程与 C 扩展的并发策略

好的，让我们来聊聊Python GIL这个磨人的小妖精，以及如何用多进程和C扩展来绕过它，实现真正的并发。

讲座：Python GIL绕过：多进程与C扩展的并发策略

大家好！今天我们来聊聊Python程序员绕不开的一个话题：GIL，也就是全局解释器锁（Global Interpreter Lock）。这玩意儿就像一个“锁头”，锁住了Python解释器，让同一时刻只能有一个线程执行Python字节码。这在多核CPU时代简直是种浪费！

想象一下，你买了8核CPU，结果Python程序只能用1核，其他7核只能眼巴巴地看着。是不是感觉血亏？所以，绕过GIL，让Python程序真正利用多核CPU，就成了我们Python程序员的必修课。

一、GIL是个什么鬼？

首先，我们得搞清楚GIL到底是什么。简单来说，GIL是CPython解释器中的一个互斥锁，它确保在任何时刻，只有一个线程可以持有Python解释器的控制权。

为什么要有GIL？

这得追溯到Python诞生的年代。那时多核CPU还没普及，GIL的存在主要是为了简化CPython解释器的内存管理，特别是引用计数机制。有了GIL，就不用担心多个线程同时修改同一个对象的引用计数，从而避免一些复杂的并发问题。

GIL的缺点

GIL的缺点也很明显：

无法利用多核CPU： 由于GIL的存在，Python的多线程程序无法真正并行执行，只能并发执行。并发是指多个任务在一段时间内交替执行，而并行是指多个任务同时执行。
I/O密集型任务影响不大： 对于I/O密集型任务（比如网络请求、文件读写），线程通常会等待I/O操作完成，此时GIL会被释放，其他线程可以获得执行机会。所以，GIL对I/O密集型任务的影响相对较小。
CPU密集型任务性能瓶颈： 对于CPU密集型任务（比如复杂的数学计算、图像处理），线程会一直占用CPU，GIL始终被持有，导致其他线程无法执行，性能瓶颈非常明显。

二、绕过GIL的策略

既然GIL这么讨厌，我们该如何绕过它呢？主要有两种方法：

多进程（Multiprocessing）： 利用操作系统的多进程机制，每个进程都有自己独立的Python解释器和内存空间，从而绕过GIL的限制。
C扩展（C Extensions）： 将CPU密集型任务用C语言编写，并在C代码中释放GIL，让其他线程可以并行执行Python代码。

三、多进程：化整为零的策略

多进程是绕过GIL最常用的方法。Python的multiprocessing模块提供了创建和管理进程的工具。

原理

每个进程都有自己独立的Python解释器和内存空间，因此GIL只存在于单个进程内部，不会影响其他进程的执行。

示例

import multiprocessing
import time

def cpu_bound_task(n):
    """模拟一个CPU密集型任务"""
    count = 0
    for i in range(n):
        count += i
    return count

def main():
    n = 100000000  # 大量的计算
    start_time = time.time()

    # 单进程执行
    result_single = cpu_bound_task(n)
    end_time_single = time.time()
    print(f"单进程执行时间: {end_time_single - start_time:.4f} 秒, 结果: {result_single}")

    # 多进程执行
    num_processes = multiprocessing.cpu_count()  # 获取CPU核心数
    pool = multiprocessing.Pool(processes=num_processes)
    results = []
    for i in range(num_processes):
        results.append(pool.apply_async(cpu_bound_task, (n // num_processes,)))  # 将任务分配给不同的进程
    pool.close()
    pool.join()  # 等待所有进程完成

    end_time_multi = time.time()
    total_result = sum([res.get() for res in results])
    print(f"多进程执行时间: {end_time_multi - end_time_single:.4f} 秒, 结果: {total_result}")

if __name__ == "__main__":
    main()

代码解释

cpu_bound_task(n)：模拟一个CPU密集型任务，进行大量的计算。
multiprocessing.cpu_count()：获取CPU核心数，用于创建进程池。
multiprocessing.Pool(processes=num_processes)：创建一个进程池，指定进程数量。
pool.apply_async(cpu_bound_task, (n // num_processes,))：将任务分配给进程池中的一个进程异步执行。
pool.close()：关闭进程池，不再接受新的任务。
pool.join()：等待进程池中的所有进程完成。
res.get()：获取异步任务的结果。

优点

真正并行： 每个进程都有独立的Python解释器和内存空间，可以真正并行执行。
简单易用： multiprocessing模块提供了简单易用的API，方便创建和管理进程。

缺点

进程间通信开销大： 进程间通信需要使用IPC（Inter-Process Communication）机制，比如管道、队列、共享内存等，开销较大。
内存占用高： 每个进程都有独立的内存空间，内存占用较高。
启动开销大： 启动进程需要创建新的Python解释器和内存空间，开销较大。

适用场景

CPU密集型任务，需要利用多核CPU的并行计算能力。
任务之间相互独立，不需要频繁的进程间通信。

四、C扩展：曲线救国的策略

如果你的CPU密集型任务可以用C语言编写，那么C扩展也是一个不错的选择。

原理

C扩展可以直接操作内存，并且可以在C代码中手动释放GIL，让其他线程可以并行执行Python代码。

示例

首先，创建一个C源文件 my_module.c：

#include <Python.h>
#include <stdio.h>

// 一个CPU密集型的C函数，用于计算阶乘
long long factorial(int n) {
    long long result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

// Python包装函数
static PyObject* py_factorial(PyObject* self, PyObject* args) {
    int n;
    if (!PyArg_ParseTuple(args, "i", &n)) {
        return NULL; // 参数解析失败
    }

    // 计算阶乘，释放GIL
    long long result;
    Py_BEGIN_ALLOW_THREADS
    result = factorial(n);
    Py_END_ALLOW_THREADS

    return PyLong_FromLongLong(result);
}

// 方法列表
static PyMethodDef MyModuleMethods[] = {
    {"factorial",  py_factorial, METH_VARARGS, "Calculate the factorial of a number."},
    {NULL, NULL, 0, NULL}        /* Sentinel */
};

// 模块定义
static struct PyModuleDef mymodule = {
    PyModuleDef_HEAD_INIT,
    "my_module",   /* name of module */
    NULL,          /* module documentation, may be NULL */
    -1,            /* size of per-interpreter state of the module,
                     or -1 if the module keeps state in global variables. */
    MyModuleMethods
};

// 模块初始化函数
PyMODINIT_FUNC
PyInit_my_module(void)
{
    return PyModule_Create(&mymodule);
}

代码解释

factorial(int n)：一个CPU密集型的C函数，用于计算阶乘。
py_factorial(PyObject* self, PyObject* args)：Python包装函数，用于将C函数暴露给Python使用。
PyArg_ParseTuple(args, "i", &n)：解析Python传递的参数，"i"表示整数类型。
Py_BEGIN_ALLOW_THREADS 和 Py_END_ALLOW_THREADS：用于释放和重新获取GIL，让其他线程可以并行执行Python代码。
PyLong_FromLongLong(result)：将C语言的long long类型转换为Python的long类型。
MyModuleMethods：方法列表，用于定义模块中可用的函数。
mymodule：模块定义，用于定义模块的名称、文档等信息。
PyInit_my_module(void)：模块初始化函数，用于创建模块对象。

接下来，创建一个 setup.py 文件，用于编译C扩展：

from setuptools import setup, Extension

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

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

然后，使用以下命令编译C扩展：

python setup.py build_ext --inplace

最后，在Python代码中使用C扩展：

import my_module
import time
import threading

def cpu_bound_task(n):
    """使用C扩展计算阶乘"""
    return my_module.factorial(n)

def main():
    n = 25  # 稍微大一点的数
    start_time = time.time()

    # 单线程执行
    result_single = cpu_bound_task(n)
    end_time_single = time.time()
    print(f"单线程执行时间: {end_time_single - start_time:.4f} 秒, 结果: {result_single}")

    # 多线程执行
    num_threads = 4
    results = []
    threads = []
    for i in range(num_threads):
        thread = threading.Thread(target=lambda: results.append(cpu_bound_task(n)))
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    end_time_multi = time.time()
    print(f"多线程执行时间: {end_time_multi - end_time_single:.4f} 秒, 结果: {results}")

if __name__ == "__main__":
    main()

代码解释

import my_module：导入编译好的C扩展模块。
my_module.factorial(n)：调用C扩展中的factorial函数。
threading.Thread：创建线程，用于并行执行C扩展中的函数。

优点

性能高： C语言的执行效率比Python高，可以提高CPU密集型任务的性能。
真正并行： 在C代码中释放GIL，让其他线程可以并行执行Python代码。

缺点

编写复杂： 需要编写C代码，对C语言的掌握程度要求较高。
调试困难： C代码的调试比Python代码困难。
平台依赖： C扩展需要针对不同的平台进行编译。

适用场景

CPU密集型任务，需要极致的性能。
对C语言比较熟悉，能够编写和调试C代码。

五、多进程 vs C扩展

那么，多进程和C扩展，到底该选择哪一个呢？

特性	多进程	C扩展
并行方式	真正并行	真正并行（需要手动释放GIL）
编程复杂度	简单易用	相对复杂
进程间通信	开销大	无需进程间通信
内存占用	高	低
启动开销	大	小
适用场景	任务之间相互独立，不需要频繁的进程间通信	需要极致的性能，对C语言比较熟悉

总结

多进程： 简单粗暴，适合任务之间相互独立，不需要频繁的进程间通信的CPU密集型任务。
C扩展： 精雕细琢，适合需要极致的性能，并且对C语言比较熟悉的CPU密集型任务。

六、一些额外的建议

选择合适的并发模型： 根据任务的特点选择合适的并发模型，比如多线程、多进程、协程等。
避免共享状态： 尽量避免多个线程或进程共享状态，以减少锁的竞争。
使用线程池或进程池： 避免频繁创建和销毁线程或进程，可以使用线程池或进程池来提高性能。
使用性能分析工具： 使用性能分析工具（比如cProfile、line_profiler）来定位性能瓶颈。

七、总结

GIL是Python并发编程的一大挑战，但我们可以通过多进程和C扩展等方法来绕过它，实现真正的并行。选择哪种方法取决于任务的特点和你的技能水平。希望今天的讲座能帮助你更好地理解GIL，并在实际项目中选择合适的并发策略。

最后，记住一句至理名言：没有银弹！ 没有一种方法可以解决所有问题。我们需要根据实际情况，灵活选择合适的并发策略。

谢谢大家！

发表回复 取消回复

发表回复取消回复