python如何创建多进程

Python创建多进程的方法有多种，包括使用multiprocessing模块、concurrent.futures模块、以及os.fork()方法。其中，multiprocessing模块是最常用且功能强大的方法，因为它提供了易用的接口、共享数据的功能和跨平台的兼容性。在使用multiprocessing模块时，你可以通过创建Process对象来启动新进程，并通过join()方法来确保主进程等待子进程完成。在此基础上，可以进一步探索使用Pool对象来管理进程池，这能够提高资源利用效率并简化并行任务的管理。

一、MULTIPROCESSING模块

multiprocessing模块是Python标准库中用于创建多进程的主要工具。它提供了多种方法来启动和管理子进程。

基本使用

multiprocessing模块的核心是Process类。你可以通过创建Process对象并调用其start()方法来启动新进程。以下是一个简单的示例：
```
from multiprocessing import Process
def worker():
    print("Worker process is running")
if __name__ == '__main__':
    process = Process(target=worker)
    process.start()
    process.join()  # 等待子进程结束
```
在这个示例中，我们定义了一个名为worker的函数，然后通过Process类创建了一个子进程来运行该函数。start()方法启动子进程，join()方法则让主进程等待子进程结束。

进程间通信

multiprocessing模块提供了多种进程间通信的方法，包括Queue、Pipe和Value等。

Queue: 多进程安全的队列，适用于需要在线程之间传递数据的场景。

from multiprocessing import Process, Queue
def worker(q):
    q.put("Data from worker")
if __name__ == '__main__':
    q = Queue()
    process = Process(target=worker, args=(q,))
    process.start()
    print(q.get())  # 从队列中获取数据
    process.join()

Pipe: 提供了双向通信的能力，可以创建两个连接点，数据可以在两个进程之间传递。

from multiprocessing import Process, Pipe
def worker(conn):
    conn.send("Message from worker")
    conn.close()
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    process = Process(target=worker, args=(child_conn,))
    process.start()
    print(parent_conn.recv())  # 接收子进程发送的数据
    process.join()

共享数据

multiprocessing模块还提供了共享内存的能力，通过Value和Array来实现。

Value: 可以在进程之间共享单个数据。

from multiprocessing import Process, Value
def worker(v):
    v.value = 42
if __name__ == '__main__':
    v = Value('i', 0)
    process = Process(target=worker, args=(v,))
    process.start()
    process.join()
    print(v.value)  # 输出42

Array: 允许在进程之间共享数组。

from multiprocessing import Process, Array
def worker(arr):
    for i in range(len(arr)):
        arr[i] = -arr[i]
if __name__ == '__main__':
    arr = Array('i', [1, 2, 3, 4, 5])
    process = Process(target=worker, args=(arr,))
    process.start()
    process.join()
    print(arr[:])  # 输出[-1, -2, -3, -4, -5]

二、POOL对象

Pool对象提供了一种更高层次的接口来管理进程池，适合处理大量并行任务。使用Pool可以方便地将任务分配到多个进程中运行。

基本使用

Pool对象允许你创建一个进程池，并将任务分配给这些进程。以下是一个简单的示例：
```
from multiprocessing import Pool
def square(x):
    return x * x
if __name__ == '__main__':
    with Pool(4) as pool:
        results = pool.map(square, [1, 2, 3, 4, 5])
    print(results)  # 输出[1, 4, 9, 16, 25]
```
在这个示例中，我们创建了一个包含4个进程的进程池，并使用map()方法将square函数应用于每个输入值。map()方法会自动将任务分配给进程池中的进程，并返回结果列表。

异步任务

Pool还支持异步任务执行，通过apply_async()和map_async()方法可以实现。

apply_async: 异步地应用一个函数。

from multiprocessing import Pool
def square(x):
    return x * x
if __name__ == '__main__':
    with Pool(4) as pool:
        result = pool.apply_async(square, (10,))
        print(result.get())  # 输出100

map_async: 异步地映射一个可迭代对象。

from multiprocessing import Pool
def square(x):
    return x * x
if __name__ == '__main__':
    with Pool(4) as pool:
        results = pool.map_async(square, [1, 2, 3, 4, 5])
        print(results.get())  # 输出[1, 4, 9, 16, 25]

使用异步任务可以避免阻塞主进程，同时可以在任务完成时通过get()方法获取结果。

三、CONCURRENT.FUTURES模块

concurrent.futures模块提供了更高级别的接口来处理并发任务，支持线程和进程两种并发模型。

基本使用

concurrent.futures提供了ProcessPoolExecutor类来管理进程池。以下是一个简单的示例：

from concurrent.futures import ProcessPoolExecutor
def square(x):
    return x * x
if __name__ == '__main__':
    with ProcessPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(square, [1, 2, 3, 4, 5]))
    print(results)  # 输出[1, 4, 9, 16, 25]

在这个示例中，我们创建了一个ProcessPoolExecutor对象，并使用map()方法将square函数应用于每个输入值。

异步任务

ProcessPoolExecutor支持异步任务执行，通过submit()方法可以实现。

from concurrent.futures import ProcessPoolExecutor
def square(x):
    return x * x
if __name__ == '__main__':
    with ProcessPoolExecutor(max_workers=4) as executor:
        future = executor.submit(square, 10)
        print(future.result())  # 输出100

使用submit()方法可以提交一个任务，并立即返回一个Future对象。可以通过result()方法获取任务结果。

四、OS.FORK()方法

os.fork()是Unix系统中用于创建进程的底层方法。虽然不如multiprocessing模块方便，但在某些情况下可能需要直接使用。

基本使用

os.fork()方法会创建一个新的子进程，子进程会从调用fork()的地方继续执行。以下是一个简单的示例：
```
import os
def worker():
    print("Worker process is running")
if __name__ == '__main__':
    pid = os.fork()
    if pid == 0:
        worker()
    else:
        os.wait()  # 等待子进程结束
```
在这个示例中，我们使用os.fork()创建了一个子进程。子进程会返回0，而父进程会返回子进程的PID。通过检查pid的值，我们可以区分父进程和子进程。
注意事项

使用os.fork()时需要注意以下几点：
- 平台限制: os.fork()仅在Unix系统上可用，在Windows系统上不可用。
- 资源共享: 子进程会继承父进程的资源，包括文件描述符和内存。
- 信号处理: 需要小心处理信号和异常，以避免不必要的资源泄露。

总结，Python提供了多种创建多进程的方法，选择合适的方法取决于具体的需求和使用场景。multiprocessing模块是最常用的方法，提供了丰富的功能和良好的跨平台支持。concurrent.futures模块则提供了更高级别的接口，适合处理并发任务。os.fork()虽然底层，但在某些Unix系统中仍然有其应用价值。通过合理使用这些工具，可以有效提高Python程序的并行处理能力。