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

好的，各位观众老爷们，欢迎来到今天的Python并发绕坑指南！咱们今天的主题是“Python GIL 绕过：多进程与 C 扩展的并发策略”。

首先，咱们得先聊聊这个让无数Python开发者又爱又恨的玩意儿——GIL，也就是全局解释器锁（Global Interpreter Lock）。

GIL是个啥？为啥它是坑？

简单来说，GIL就像一个霸道的门卫，守在Python解释器的大门口。每次只允许一个线程进入解释器执行Python字节码。也就是说，即使你的电脑是八核处理器，你的Python程序的多线程也只能用到一个核心。这就像你买了辆法拉利，结果只能在村里土路上开，憋屈不？

那为啥要有GIL呢？这得追溯到Python最初的设计。GIL主要是为了简化CPython解释器的内存管理，并防止多个线程同时修改共享对象，从而保证线程安全。但是，它也带来了并发的瓶颈，特别是对于CPU密集型的任务。

GIL的影响有多大？

想象一下，你有个程序需要计算1000万个斐波那契数列。如果你用多线程来加速，你会发现，速度几乎没有提升，甚至可能更慢！这是因为GIL的存在，所有线程都在抢夺解释器的执行权，造成了额外的开销。

但是，GIL也不是一无是处。对于IO密集型的任务，比如网络请求、文件读写等，多线程仍然可以发挥作用。因为线程在等待IO操作完成时，会释放GIL，让其他线程有机会执行。

那么，我们如何绕过GIL，实现真正的并发呢？

别担心，办法总是有的！咱们今天主要介绍两种常用的策略：多进程和C扩展。

策略一：多进程大法好！

既然一个解释器只能跑一个线程，那咱们就启动多个解释器呗！这就是多进程的思路。

原理：

多进程是指启动多个独立的Python解释器进程，每个进程都有自己独立的内存空间和GIL。这样，每个进程都可以充分利用多核CPU的资源，实现真正的并行计算。

实现：

Python的multiprocessing模块提供了创建和管理进程的强大工具。

import multiprocessing
import time

def fibonacci(n):
    if n <= 1:
        return n
    else:
        return fibonacci(n-1) + fibonacci(n-2)

def worker(n):
    print(f"进程 {multiprocessing.current_process().name} 开始计算 fib({n})")
    start_time = time.time()
    result = fibonacci(n)
    end_time = time.time()
    print(f"进程 {multiprocessing.current_process().name} 计算 fib({n}) 结果: {result}，耗时: {end_time - start_time:.4f} 秒")

if __name__ == '__main__':
    numbers = [35, 36, 37, 38]
    processes = []

    start_time = time.time()

    # 创建多个进程
    for i, n in enumerate(numbers):
        p = multiprocessing.Process(target=worker, args=(n,), name=f"Process-{i+1}")
        processes.append(p)
        p.start()

    # 等待所有进程完成
    for p in processes:
        p.join()

    end_time = time.time()
    print(f"总耗时: {end_time - start_time:.4f} 秒")

    #单进程版本
    start_time = time.time()
    for i, n in enumerate(numbers):
        worker(n)
    end_time = time.time()
    print(f"单进程总耗时: {end_time - start_time:.4f} 秒")

代码解释：

fibonacci(n)函数：用于计算斐波那契数列的递归函数，这是一个典型的CPU密集型任务。
worker(n)函数：每个进程执行的任务，计算并打印斐波那契数列的结果。
multiprocessing.Process()：创建进程对象，指定要执行的函数和参数。
p.start()：启动进程。
p.join()：等待进程完成。
包含了单进程版本进行耗时对比

优点：

真正实现了并行计算，可以充分利用多核CPU。
每个进程都有独立的内存空间，避免了线程安全问题。

缺点：

进程间的通信开销较大，需要使用multiprocessing模块提供的队列、管道等机制。
进程的创建和销毁开销也比较大。
内存占用较高，每个进程都需要分配独立的内存空间。

适用场景：

CPU密集型任务，比如科学计算、图像处理、机器学习等。
需要隔离不同任务的场景，比如服务器处理不同的请求。

进程间通信：

多进程之间需要进行数据交换，常用的方法有：

队列（Queue）： 线程安全的消息队列，可以用于进程间传递数据。
管道（Pipe）： 提供了两个连接的文件对象，可以用于进程间双向通信。
共享内存（Shared Memory）： 允许多个进程访问同一块内存区域，速度最快，但需要注意同步问题。
远程过程调用（RPC）： 使用网络协议进行进程间通信，适用于分布式系统。

代码示例（使用队列）：

import multiprocessing

def producer(queue):
    for i in range(5):
        queue.put(i)
        print(f"生产者放入数据: {i}")

def consumer(queue):
    while True:
        try:
            item = queue.get(timeout=1) # 设置超时时间，防止阻塞
            print(f"消费者取出数据: {item}")
        except queue.Empty:
            print("队列为空，消费者退出")
            break

if __name__ == '__main__':
    queue = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=producer, args=(queue,))
    p2 = multiprocessing.Process(target=consumer, args=(queue,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

策略二：C扩展，曲线救国！

如果多进程的开销太大，或者你需要更精细的控制，那么C扩展可能是一个不错的选择。

原理：

C扩展是指使用C、C++等语言编写Python模块，然后通过Python的API将其导入到Python程序中使用。由于C代码在执行时可以释放GIL，因此可以实现真正的并行计算。

实现：

编写C代码： 使用Python的C API编写模块，包含需要并行的函数。在执行耗时操作前释放GIL，操作完成后再获取GIL。
编译C代码： 将C代码编译成共享库（.so文件）。
在Python中导入： 使用import语句导入共享库，并调用其中的函数。

代码示例（使用ctypes）：

# my_module.c
#include <Python.h>
#include <stdio.h>
#include <pthread.h>

static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

static PyObject* heavy_computation(PyObject* self, PyObject* args) {
    int n;
    if (!PyArg_ParseTuple(args, "i", &n)) {
        return NULL;
    }

    // 释放GIL
    Py_BEGIN_ALLOW_THREADS

    pthread_mutex_lock(&mutex);  // 使用互斥锁保护共享资源
    double result = 0.0;
    for (int i = 0; i < n; i++) {
        result += i * 1.0; // 模拟耗时计算
    }
    pthread_mutex_unlock(&mutex);

    // 重新获取GIL
    Py_END_ALLOW_THREADS

    return PyFloat_FromDouble(result);
}

static PyMethodDef MyModuleMethods[] = {
    {"heavy_computation",  heavy_computation, METH_VARARGS, "Do a heavy computation."},
    {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);
}

# setup.py
from distutils.core 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])

# main.py
import my_module
import time
import threading

def worker(n):
    start_time = time.time()
    result = my_module.heavy_computation(n)
    end_time = time.time()
    print(f"线程 {threading.current_thread().name} 计算结果: {result}，耗时: {end_time - start_time:.4f} 秒")

if __name__ == '__main__':
    # 先编译C扩展
    # python setup.py build_ext --inplace

    threads = []
    start_time = time.time()
    for i in range(4):
        t = threading.Thread(target=worker, args=(10000000,), name=f"Thread-{i+1}")
        threads.append(t)
        t.start()

    for t in threads:
        t.join()
    end_time = time.time()
    print(f"总耗时: {end_time - start_time:.4f} 秒")

编译和运行：

编译C扩展： 在命令行中执行python setup.py build_ext --inplace。这将在当前目录下生成my_module.so（或者my_module.pyd在Windows上）。
运行Python程序： 执行python main.py。

代码解释：

C代码：
- Py_BEGIN_ALLOW_THREADS和Py_END_ALLOW_THREADS：用于释放和获取GIL的宏。
- pthread_mutex_lock和pthread_mutex_unlock：使用互斥锁保护共享资源，防止多个线程同时修改。
- PyArg_ParseTuple：解析Python传递的参数。
- PyFloat_FromDouble：将C的double类型转换为Python的float类型。
Python代码：
- import my_module：导入C扩展模块。
- my_module.heavy_computation(n)：调用C扩展中的函数。

优点：

可以绕过GIL，实现真正的并行计算。
可以利用C/C++的性能优势。
可以更精细地控制线程的同步和互斥。

缺点：

编写C扩展比较复杂，需要熟悉Python的C API。
需要处理内存管理和线程安全问题。
可移植性较差，需要为不同的平台编译不同的版本。

适用场景：

需要高性能计算的场景。
需要访问底层系统资源的场景。
需要与其他语言进行集成的场景。

总结：

特性	多进程	C扩展
并行性	真正并行，每个进程有独立的GIL	可以通过释放GIL实现并行
复杂度	相对简单，使用`multiprocessing`模块	较复杂，需要熟悉C API和线程安全
通信开销	较大，需要使用队列、管道等机制	较小，可以通过共享内存等方式
内存占用	较高，每个进程都需要独立的内存空间	较低，可以在同一个进程中共享内存
可移植性	较好	较差，需要为不同平台编译不同版本
适用场景	CPU密集型任务，需要隔离不同任务的场景	需要高性能计算，需要访问底层系统资源的场景

如何选择？

选择哪种策略取决于你的具体需求。

如果你的任务是CPU密集型的，并且对性能要求较高，那么可以考虑使用多进程或C扩展。
如果你的任务是IO密集型的，那么使用多线程可能就足够了。
如果你的程序比较简单，并且对性能要求不高，那么可以继续使用多线程，并尽量避免CPU密集型的操作。

最后的忠告：

在进行并发编程时，一定要注意线程安全问题，避免出现数据竞争和死锁。
在选择并发策略时，要根据实际情况进行权衡，选择最适合你的方案。
测试，测试，再测试！在生产环境中使用并发代码之前，一定要进行充分的测试，确保其稳定性和正确性。

好了，今天的Python并发绕坑指南就到这里。希望大家以后在遇到GIL这个拦路虎时，能够游刃有余地绕过去，写出高效、稳定的Python程序！各位，下次再见！

发表回复 取消回复

发表回复取消回复