python多进程学习详细版
时间: 2023-08-09 19:12:31 浏览: 55
Python 多进程是指在同一个程序中同时运行多个进程,这些进程可以并发运行,从而提高程序的执行效率。Python 提供了多种实现多进程的方式,其中最常用的是 `multiprocessing` 模块。
## multiprocessing 模块简介
`multiprocessing` 模块是 Python 标准库中的一部分,提供了创建和管理进程的功能。使用该模块可以方便地实现多进程编程。
`multiprocessing` 模块中最常用的类是 `Process` 类,该类用于创建新的进程。`Process` 类的构造函数接受一个函数作为参数,并将该函数作为新进程的入口函数。
下面是一个简单的示例代码:
```python
import multiprocessing
def worker():
print('Worker')
if __name__ == '__main__':
process = multiprocessing.Process(target=worker)
process.start()
process.join()
```
上面的代码中,首先导入 `multiprocessing` 模块,然后定义了一个 `worker` 函数,该函数将在子进程中运行。在主进程中,创建了一个子进程 `process`,并将 `worker` 函数作为参数传递给该进程。然后,调用 `process.start()` 方法启动进程,调用 `process.join()` 方法等待进程结束。
## 进程间通信
在多进程编程中,进程之间需要进行通信以完成一些协同工作。Python 提供了多种实现进程间通信的方式,如 `Queue`、`Pipe`、`Value` 和 `Array` 等。
### Queue
`Queue` 类是 `multiprocessing` 模块中提供的一个进程安全的队列。多个进程可以同时将数据放入队列和从队列中取出数据,而不会出现数据冲突的问题。
下面是一个简单的示例代码:
```python
import multiprocessing
def worker(queue):
data = queue.get()
print('Worker:', data)
if __name__ == '__main__':
queue = multiprocessing.Queue()
queue.put('Hello')
process = multiprocessing.Process(target=worker, args=(queue,))
process.start()
process.join()
```
上面的代码中,首先创建了一个 `Queue` 对象 `queue`,然后向该队列中放入了一个字符串 `'Hello'`。然后,创建了一个子进程 `process`,并将 `queue` 作为参数传递给该进程。在子进程中,调用 `queue.get()` 方法从队列中取出数据,并打印出来。
### Pipe
`Pipe` 类是 `multiprocessing` 模块中提供的一个进程间通信管道。该类提供了两个连接,每个连接都是一个独立的双向通道,可以同时进行读写操作。
下面是一个简单的示例代码:
```python
import multiprocessing
def worker(connection):
data = connection.recv()
print('Worker:', data)
connection.send('Hello from worker')
if __name__ == '__main__':
parent_conn, child_conn = multiprocessing.Pipe()
parent_conn.send('Hello from parent')
process = multiprocessing.Process(target=worker, args=(child_conn,))
process.start()
print('Parent:', parent_conn.recv())
process.join()
```
上面的代码中,首先创建了一个 `Pipe` 对象,然后向父进程的连接 `parent_conn` 中发送了一个字符串 `'Hello from parent'`。然后,创建了一个子进程 `process`,并将子进程的连接 `child_conn` 作为参数传递给该进程。在子进程中,调用 `connection.recv()` 方法从连接中接收数据,并打印出来,然后调用 `connection.send()` 方法向连接中发送数据。
### Value 和 Array
`Value` 和 `Array` 类是 `multiprocessing` 模块中提供的两个共享内存对象。这两个类可以在多个进程之间共享数据。
`Value` 类用于共享一个单一的值,而 `Array` 类用于共享一个数组。
下面是一个简单的示例代码:
```python
import multiprocessing
def worker(value, array):
value.value = 5
array[0] = 1
if __name__ == '__main__':
value = multiprocessing.Value('i', 0)
array = multiprocessing.Array('i', [0, 0, 0])
process = multiprocessing.Process(target=worker, args=(value, array))
process.start()
process.join()
print('Value:', value.value)
print('Array:', array[:])
```
上面的代码中,首先创建了一个 `Value` 对象 `value`,并初始化为 `0`。然后,创建了一个 `Array` 对象 `array`,并初始化为 `[0, 0, 0]`。然后,创建了一个子进程 `process`,并将 `value` 和 `array` 作为参数传递给该进程。在子进程中,将 `value.value` 设置为 `5`,将 `array[0]` 设置为 `1`。在主进程中,打印出 `value.value` 和 `array` 的值。
## 进程池
在实际应用中,可能需要同时启动多个进程来完成一些任务,但是创建过多的进程会导致系统资源的浪费。为了解决这个问题,可以使用进程池来管理进程。
Python 提供了 `multiprocessing.Pool` 类来实现进程池。该类可以自动创建一定数量的进程,并管理这些进程的生命周期。
下面是一个简单的示例代码:
```python
import multiprocessing
def worker(data):
print('Worker:', data)
if __name__ == '__main__':
pool = multiprocessing.Pool(processes=2)
for i in range(10):
pool.apply_async(worker, args=(i,))
pool.close()
pool.join()
```
上面的代码中,首先创建了一个进程池 `pool`,并设置最大进程数为 `2`。然后,循环 `10` 次,向进程池中添加任务。在每次循环中,调用 `pool.apply_async()` 方法向进程池中添加一个任务,并将任务的参数作为参数传递给该方法。最后,调用 `pool.close()` 方法关闭进程池,并调用 `pool.join()` 方法等待所有任务完成。
## 多进程编程的注意事项
在多进程编程中,需要注意以下几点:
1. 必须在 `if __name__ == '__main__':` 语句块中创建进程,否则可能会导致进程无法启动或者崩溃。
2. 进程间共享的对象必须使用 `Value`、`Array` 或者 `Manager` 等进程安全的对象。
3. 在使用进程池时,需要注意任务之间的依赖关系和执行顺序。
4. 必须正确处理进程间通信的数据格式,避免出现数据不一致的问题。
5. 多进程编程可能导致代码复杂度增加,需要仔细考虑是否真正需要使用多进程。