Python多进程编程详解：从基础到实践-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00126/article/details/148783138

Python多进程编程详解：从基础到实践

explore-python :green_book: The Beauty of Python Programming. 项目地址: https://gitcode.com/gh_mirrors/ex/explore-python

什么是进程

进程（Process）是计算机科学中的一个核心概念，它代表了一个正在执行的程序实例。每个进程都拥有独立的内存空间、数据栈和系统资源，操作系统通过进程来分配和管理计算资源。

举个生活中的例子：当你打开一个音乐播放器听歌时，这个播放器就是一个进程；同时你又打开了一个文档编辑器写文章，编辑器是另一个进程。这两个进程互不干扰，各自运行。

进程的基本特性

独立性：每个进程都有自己独立的内存空间和系统资源
并发性：多个进程可以在单核CPU上通过时间片轮转实现"同时"运行
动态性：进程有创建、执行、暂停和终止等生命周期
结构性：每个进程都有代码段、数据段和进程控制块(PCB)

Unix/Linux中的fork机制

在Unix/Linux系统中，fork()是一个非常重要的系统调用，它用于创建新的进程。这个函数的特点是"调用一次，返回两次"：

在父进程中返回子进程的PID
在子进程中返回0

这种机制使得父进程和子进程可以执行不同的代码路径。下面是一个简单的C语言示例：

#include <unistd.h>
#include <stdio.h>

int main() {
    int pid = fork();
    
    if (pid < 0) {
        printf("创建进程失败\n");
    } else if (pid == 0) {
        printf("我是子进程(%d)，我的父进程是(%d)\n", getpid(), getppid());
    } else {
        printf("我是父进程(%d)，我创建了子进程(%d)\n", getpid(), pid);
    }
    return 0;
}

Python的os模块也提供了fork函数，使得我们可以在Python中实现类似的功能：

import os

pid = os.fork()

if pid < 0:
    print('创建进程失败')
elif pid == 0:
    print(f'我是子进程({os.getpid()})，我的父进程是({os.getppid()})')
else:
    print(f'我是父进程({os.getpid()})，我创建了子进程({pid})')

Python中的多进程编程

Python提供了multiprocessing模块来简化多进程编程，它屏蔽了不同操作系统间的差异，提供了统一的接口。

创建单个进程

import os
from multiprocessing import Process

def child_process(name):
    print(f'运行子进程 {name} ({os.getpid()})')

if __name__ == '__main__':
    print(f'父进程 {os.getpid()}')
    p = Process(target=child_process, args=('测试',))
    print('进程即将启动')
    p.start()
    p.join()
    print('进程结束')

这段代码展示了如何创建一个子进程并等待它完成。Process类封装了进程的创建和管理，start()方法启动进程，join()方法等待进程结束。

跨平台注意事项

需要注意的是，multiprocessing模块在不同平台下的行为可能不同，主要体现在进程创建方式上：

Windows平台：使用spawn方式创建进程，子进程会重新导入主模块
Unix/Linux平台：默认使用fork方式创建进程，子进程会继承父进程的状态

这种差异可能导致一些意外行为，比如全局变量在不同平台下的表现不一致。

使用进程池管理多个进程

当需要创建大量进程时，使用进程池(Pool)是更高效的方式：

import os
import time
from multiprocessing import Pool

def task(x):
    print(f'执行任务 {x} (pid:{os.getpid()})')
    time.sleep(2)
    return x * x

if __name__ == '__main__':
    print(f'主进程 {os.getpid()}')
    with Pool(4) as p:  # 创建包含4个进程的池
        results = p.map(task, range(5))  # 并行执行任务
    print('所有子进程完成')
    print(f'结果: {results}')

进程池会自动管理进程的创建和销毁，map方法可以并行处理可迭代对象中的每个元素。

进程间通信(IPC)

由于进程间内存隔离，Python提供了多种进程间通信机制：

使用队列(Queue)

from multiprocessing import Process, Queue
import time

def producer(q):
    for i in range(5):
        print(f'生产: {i}')
        q.put(i)
        time.sleep(0.5)

def consumer(q):
    while True:
        item = q.get()
        if item is None:  # 使用None作为结束信号
            break
        print(f'消费: {item}')

if __name__ == '__main__':
    q = Queue()
    p1 = Process(target=producer, args=(q,))
    p2 = Process(target=consumer, args=(q,))
    
    p1.start()
    p2.start()
    
    p1.join()
    q.put(None)  # 发送结束信号
    p2.join()

使用管道(Pipe)

from multiprocessing import Process, Pipe

def sender(conn):
    conn.send('Hello from sender')
    conn.close()

def receiver(conn):
    msg = conn.recv()
    print(f'收到消息: {msg}')
    conn.close()

if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p1 = Process(target=sender, args=(child_conn,))
    p2 = Process(target=receiver, args=(parent_conn,))
    
    p1.start()
    p2.start()
    
    p1.join()
    p2.join()