分类： 软件

在编程的世界里，Python因其简洁的语法和强大的功能深受开发者的喜爱。然而，当我们谈及多进程时，Windows和Linux就像两位性格截然不同的角色，各自有着独特的表现方式。今天，我们将揭开这一神秘面纱，深入探讨它们之间的区别，以及如何在这两者之间架起桥梁，避免潜在的错误。

🚀 简单函数的启动与阻塞

首先，我们来看一个简单的多进程示例。以下代码展示了如何使用多进程运行一个简单函数，而不会阻塞主程序：

import multiprocessing as mp
from time import sleep

def simple_func():
    print('开始 simple func')
    sleep(1)
    print('结束 simple func')

if __name__ == '__main__':
    p = mp.Process(target=simple_func)
    p.start()
    print('等待 simple_func')
    p.join()

当我们运行这段代码时，输出符合我们的预期，显示了主程序在等待子进程的消息。

🕵️‍♂️ Windows与Linux的输出对比

接下来，再来看一段稍微复杂一点的代码：

import multiprocessing as mp
from time import sleep

print('定义 simple_func 之前')

def simple_func():
    print('开始 simple func')
    sleep(1)
    print('结束 simple func')

if __name__ == '__main__':
    p = mp.Process(target=simple_func)
    p.start()
    print('等待 simple_func')
    p.join()

在Windows上运行时，你会看到以下输出：

定义 simple_func 之前
等待 simple_func
定义 simple_func 之前
开始 simple func
结束 simple func

而在Linux上，输出则是：

定义 simple_func 之前
等待 simple_func
开始 simple func
结束 simple func

这里的差异源于操作系统对进程的处理方式。在Linux中，子进程通过fork生成，继承了父进程的内存状态。而在Windows上，进程是通过spawn生成的，这意味着新的解释器启动并重新运行代码。

⚠️ 必须的if name == ‘main‘

在Windows上，如果我们没有使用if __name__ == '__main__'，将会遭遇一个看似无尽的错误信息，最终以RuntimeError告终。这个错误暗示用户，当前进程尚未完成引导阶段，试图启动新进程是行不通的。

在Linux上，虽然不会出现这个问题，但为了代码的可移植性，始终将其包含在内是个明智的选择。

🎲 随机数的奇妙之旅

再让我们看看一个涉及随机数的例子：

import multiprocessing as mp
import random

val = random.random()

def simple_func():
    print(val)

if __name__ == '__main__':
    print('multiprocessing之前:')
    simple_func()
    print('multiprocessing之后:')
    p = mp.Process(target=simple_func)
    p.start()
    p.join()

在Windows上，输出的两个值可能会有所不同，而在Linux上，两个值将保持一致。这是因为Windows和Linux在处理全局变量时的策略不同。

🔄 从Linux到Windows的迁移

如何将Linux上的代码迁移到Windows上呢？看看这个稍微复杂的示例：

import multiprocessing as mp

class MyClass:
    def __init__(self, i):
        self.i = i

    def simple_method(self):
        print('这是一个简单函数')
        print(f'保存的值是: {self.i}')

    def mp_simple_method(self):
        self.p = mp.Process(target=self.simple_method)
        self.p.start()

    def wait(self):
        self.p.join()

if __name__ == '__main__':
    my_class = MyClass(1)
    my_class.mp_simple_method()
    my_class.wait()

这段代码在Windows和Linux上均可正常运行。然而，如果我们尝试进行一些稍微复杂的操作，比如从文件中写入或读取数据时，就会出现问题。以下是一个例子：

import multiprocessing as mp

class MyClass:
    def __init__(self, i):
        self.i = i
        self.file = open(f'{i}.txt', 'w')

    def simple_method(self):
        print('这是一个简单函数')
        print(f'保存的值是: {self.i}')

    def mp_simple_method(self):
        self.p = mp.Process(target=self.simple_method)
        self.p.start()

    def wait(self):
        self.p.join()
        self.file.close()

if __name__ == '__main__':
    my_class = MyClass(1)
    my_class.mp_simple_method()
    my_class.wait()

在Linux上，这段代码可以正常工作。然而，在Windows上，就会抛出一个TypeError，提示无法序列化'_io.TextIOWrapper'对象。原因在于，Windows的spawn机制需要将整个对象进行pickle处理，而文件对象是无法被pickle的。

🛠️ 解决方案：变更进程启动方式

虽然在Windows上无法改变进程启动方式，但在Linux上可以。我们可以通过以下代码来设定启动方式：

if __name__ == '__main__':
    mp.set_start_method('spawn')
    my_class = MyClass(1)
    my_class.mp_simple_method()
    my_class.wait()

这样做将使得代码在Linux和Windows上产生相同的错误，从而保持结果的一致性。

⚖️ 设计任务的合理性

最后，让我们回顾一下多进程的速度问题。虽然多进程能够利用多个CPU加速程序，但是启动子进程的开销也不容忽视。在Windows和Mac上，Python需要对对象进行pickle处理，这可能抵消在独立进程上运行的好处。如果每个进程任务都很短，可能会导致CPU的浪费。因此，在设计多进程任务时，应合理评估任务的设计，确保子进程的运行时间不会过短。

📚 小结

在多进程处理上，Windows和Linux的差异就像两种不同的饮品，虽然各有千秋，却也各有各的调制方式。理解这些差异并灵活应对，将帮助我们在跨平台开发中游刃有余。

参考文献

1. Sprite. (2023). Python多进程在Windows 和 Linux 的区别. IT碎碎念.
2. Python官方文档. (2023). Multiprocessing — Process-based parallelism.
3. Stack Overflow. (2023). Python multiprocessing differences between Windows and Linux.
4. Real Python. (2023). Understanding Python’s Multiprocessing Module.
5. GeeksforGeeks. (2023). Multiprocessing in Python: A Guide.