python如何多进程处理

Python多进程处理可以通过使用multiprocessing模块来实现，该模块提供了一个接口来创建和管理多个进程。使用multiprocessing模块可以充分利用多核处理器的优势，提高程序的执行效率、解决GIL（全局解释器锁）问题。以下是一些实现多进程处理的常用方法：创建Process对象、使用Pool对象、队列和管道进行进程间通信、使用Manager对象进行进程间共享数据。下面我将详细介绍其中一种方法：创建Process对象。

一、创建Process对象

创建Process对象是使用多进程处理的基本方法之一。multiprocessing模块提供了一个Process类，可以通过创建Process对象并启动它们来并行执行任务。

1、创建和启动进程

首先，我们需要导入multiprocessing模块，并创建一个Process对象。Process对象需要一个目标函数和可选的参数。目标函数是在新进程中执行的代码。下面是一个简单的例子：

import multiprocessing
import os
def worker(num):
    print(f'Worker: {num}, PID: {os.getpid()}')
if __name__ == '__main__':
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

在这个例子中，我们定义了一个名为worker的函数，它接受一个参数num并打印出来。然后，我们在主程序中创建了五个Process对象，每个对象的目标函数都是worker，并传递一个不同的参数。我们启动每个进程并等待它们完成。

2、进程间通信

在多进程处理中，有时需要在进程之间进行通信。multiprocessing模块提供了几种方法来实现进程间通信，其中最常用的是队列（Queue）和管道（Pipe）。

使用队列（Queue）

队列是一个先进先出（FIFO）的数据结构，适合用来在线程或进程之间传递数据。下面是一个使用队列进行进程间通信的例子：

import multiprocessing
def worker(q, num):
    q.put(f'Worker {num} processed')
if __name__ == '__main__':
    q = multiprocessing.Queue()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(q, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
    while not q.empty():
        print(q.get())

在这个例子中，我们创建了一个队列q，并将其传递给每个子进程。每个子进程将一条消息放入队列中。主进程等待所有子进程完成后，从队列中读取并打印消息。

二、使用Pool对象

multiprocessing.Pool类提供了一种更高层次的接口来管理一组进程。它可以自动分配任务给可用的进程，并提供了一些方便的方法来处理并行任务。

1、使用apply和apply_async

apply方法是阻塞的，它会等待任务完成后返回结果。apply_async方法是非阻塞的，它会立即返回一个AsyncResult对象，可以通过get方法获取结果。

import multiprocessing
def worker(num):
    return num * 2
if __name__ == '__main__':
    with multiprocessing.Pool(5) as pool:
        results = [pool.apply(worker, (i,)) for i in range(10)]
        print(results)
        async_results = [pool.apply_async(worker, (i,)) for i in range(10)]
        print([res.get() for res in async_results])

在这个例子中，我们创建了一个包含五个进程的进程池，并使用apply和apply_async方法将任务分配给池中的进程。apply方法会返回一个结果列表，而apply_async方法会返回一个AsyncResult对象列表。

2、使用map、map_async和imap

map方法类似于Python内置的map函数，它会将一个可迭代对象中的每个元素传递给目标函数，并返回一个结果列表。map_async方法是非阻塞的，imap方法会返回一个迭代器，可以逐个获取结果。

import multiprocessing
def worker(num):
    return num * 2
if __name__ == '__main__':
    with multiprocessing.Pool(5) as pool:
        results = pool.map(worker, range(10))
        print(results)
        async_results = pool.map_async(worker, range(10))
        print(async_results.get())
        for result in pool.imap(worker, range(10)):
            print(result)

在这个例子中，我们使用map、map_async和imap方法将任务分配给进程池中的进程，并获取结果。

三、队列和管道进行进程间通信

在多进程处理中，进程间通信是一个重要的方面。multiprocessing模块提供了队列（Queue）和管道（Pipe）两种方式来实现进程间通信。

1、使用队列（Queue）

队列是一个先进先出（FIFO）的数据结构，非常适合用来在线程或进程之间传递数据。multiprocessing.Queue类提供了一个接口来创建和管理队列。

import multiprocessing
def worker(q, num):
    q.put(f'Worker {num} processed')
if __name__ == '__main__':
    q = multiprocessing.Queue()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(q, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
    while not q.empty():
        print(q.get())

2、使用管道（Pipe）

管道是一种双向通信机制，适合用来在线程或进程之间进行双向通信。multiprocessing.Pipe函数返回一对连接对象，可以用来发送和接收数据。

import multiprocessing
def worker(conn, num):
    conn.send(f'Worker {num} processed')
    conn.close()
if __name__ == '__main__':
    parent_conn, child_conn = multiprocessing.Pipe()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(child_conn, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
    while parent_conn.poll():
        print(parent_conn.recv())

在这个例子中，我们创建了一对连接对象parent_conn和child_conn，并将其中一个传递给每个子进程。每个子进程通过连接对象发送一条消息。主进程等待所有子进程完成后，通过连接对象接收并打印消息。

四、使用Manager对象进行进程间共享数据

在多进程处理中，有时需要在进程之间共享数据。multiprocessing.Manager类提供了一种方式来创建共享数据结构，如字典、列表、队列等。

1、共享列表和字典

multiprocessing.Manager类提供了list和dict方法来创建共享的列表和字典。下面是一个使用共享列表和字典的例子：

import multiprocessing
def worker(shared_list, shared_dict, num):
    shared_list.append(num)
    shared_dict[num] = f'Worker {num} processed'
if __name__ == '__main__':
    manager = multiprocessing.Manager()
    shared_list = manager.list()
    shared_dict = manager.dict()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(shared_list, shared_dict, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
    print(shared_list)
    print(shared_dict)

在这个例子中，我们创建了一个Manager对象，并使用它创建了一个共享的列表shared_list和一个共享的字典shared_dict。每个子进程向共享列表和字典中添加数据。主进程等待所有子进程完成后，打印共享列表和字典中的数据。

2、共享队列

multiprocessing.Manager类还提供了一个Queue方法来创建共享的队列。下面是一个使用共享队列的例子：

import multiprocessing
def worker(shared_queue, num):
    shared_queue.put(f'Worker {num} processed')
if __name__ == '__main__':
    manager = multiprocessing.Manager()
    shared_queue = manager.Queue()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(shared_queue, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
    while not shared_queue.empty():
        print(shared_queue.get())

在这个例子中，我们创建了一个Manager对象，并使用它创建了一个共享的队列shared_queue。每个子进程向共享队列中添加数据。主进程等待所有子进程完成后，从共享队列中读取并打印数据。

五、处理多进程中的异常

在多进程处理中，异常处理是一个重要的方面。当一个子进程中发生异常时，主进程需要能够捕获并处理这些异常。multiprocessing模块提供了一些方法来处理多进程中的异常。

1、捕获子进程异常

当一个子进程中发生异常时，可以使用Process对象的exitcode属性来检查子进程的退出状态。如果exitcode为非零值，则表示子进程中发生了异常。

import multiprocessing
def worker(num):
    if num == 2:
        raise ValueError('An error occurred')
    return num * 2
if __name__ == '__main__':
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(i,))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()
        if p.exitcode != 0:
            print(f'Process {p.pid} exited with code {p.exitcode}')

在这个例子中，当worker函数的参数为2时，会引发一个ValueError异常。主进程检查每个子进程的exitcode属性，如果exitcode为非零值，则表示子进程中发生了异常。

2、使用`apply_async`处理异常

当使用apply_async方法时，可以通过传递一个错误回调函数来处理子进程中的异常。错误回调函数会在子进程中发生异常时被调用。

import multiprocessing
def worker(num):
    if num == 2:
        raise ValueError('An error occurred')
    return num * 2
def error_callback(exc):
    print(f'Error: {exc}')
if __name__ == '__main__':
    with multiprocessing.Pool(5) as pool:
        async_results = [pool.apply_async(worker, (i,), error_callback=error_callback) for i in range(5)]
        for res in async_results:
            try:
                print(res.get())
            except Exception as e:
                print(f'Exception: {e}')

在这个例子中，我们定义了一个错误回调函数error_callback，并将其传递给apply_async方法。当worker函数中发生异常时，错误回调函数会被调用，并打印异常信息。

六、进程同步

在多进程处理中，进程同步是一个重要的方面。multiprocessing模块提供了多种同步机制，如锁（Lock）、事件（Event）、条件（Condition）和信号量（Semaphore）。

1、使用锁（Lock）

锁是一种同步机制，用于确保一次只有一个进程可以访问共享资源。multiprocessing.Lock类提供了一个接口来创建和管理锁。

import multiprocessing
def worker(lock, num):
    with lock:
        print(f'Worker {num} is processing')
if __name__ == '__main__':
    lock = multiprocessing.Lock()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(lock, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

在这个例子中，我们创建了一个锁lock，并将其传递给每个子进程。每个子进程在访问共享资源时，都会先获取锁，确保一次只有一个进程可以访问共享资源。

2、使用事件（Event）

事件是一种同步机制，用于通知一个或多个进程发生了某个事件。multiprocessing.Event类提供了一个接口来创建和管理事件。

import multiprocessing
def worker(event, num):
    event.wait()
    print(f'Worker {num} is processing')
if __name__ == '__main__':
    event = multiprocessing.Event()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(event, i))
        processes.append(p)
        p.start()
    event.set()
    for p in processes:
        p.join()

在这个例子中，我们创建了一个事件event，并将其传递给每个子进程。每个子进程在开始处理任务前，都会等待事件被设置。主进程设置事件，通知所有子进程开始处理任务。

3、使用条件（Condition）

条件是一种同步机制，用于在一个或多个进程之间进行复杂的同步操作。multiprocessing.Condition类提供了一个接口来创建和管理条件。

import multiprocessing
def worker(condition, num):
    with condition:
        condition.wait()
        print(f'Worker {num} is processing')
if __name__ == '__main__':
    condition = multiprocessing.Condition()
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(condition, i))
        processes.append(p)
        p.start()
    with condition:
        condition.notify_all()
    for p in processes:
        p.join()

在这个例子中，我们创建了一个条件condition，并将其传递给每个子进程。每个子进程在开始处理任务前，都会等待条件被通知。主进程通知所有子进程开始处理任务。

4、使用信号量（Semaphore）

信号量是一种同步机制，用于控制对共享资源的访问数量。multiprocessing.Semaphore类提供了一个接口来创建和管理信号量。

import multiprocessing
def worker(semaphore, num):
    with semaphore:
        print(f'Worker {num} is processing')
        time.sleep(1)
if __name__ == '__main__':
    semaphore = multiprocessing.Semaphore(2)
    processes = []
    for i in range(5):
        p = multiprocessing.Process(target=worker, args=(semaphore, i))
        processes.append(p)
        p.start()
    for p in processes:
        p.join()

在这个例子中，我们创建了一个信号量semaphore，并将其传递给每个子进程。信号量的初始值为2，表示最多允许两个进程同时访问共享资源。每个子进程在访问共享资源时，会先获取信号量，确保最多只有两个进程可以同时访问共享资源。

七、使用进程池来管理进程

在多进程处理中，使用进程池来管理进程是一种常见的方法。multiprocessing.Pool类提供了一种高层次的接口来管理一组进程。它可以自动分配任务给可用的进程，并提供了一些方便的方法来处理并行任务。

1、创建进程池

multiprocessing.Pool类提供了一个接口来创建和管理进程池。可以通过指定进程池的大小来创建进程池。

import multiprocessing
def worker(num):
    return num * 2
if __name__ == '__main__':
    with multiprocessing.Pool(5) as pool:
        results = pool.map(worker, range(10))
        print(results)

在这个例子中，我们创建了一个包含五个进程的进程池，并使用map方法将任务分配给池中的进程。map方法会将一个可迭代对象中的每个元素传递给目标函数，并返回一个结果列表。