介绍
python 中的多处理模块允许您创建和管理进程，使您能够充分利用机器上的多个处理器。它通过为每个进程使用单独的内存空间来帮助您实现并行执行，这与线程共享相同内存空间的线程不同。以下是多处理模块中常用的类和方法的列表，并附有简短的示例。
1. 流程
process 类是多处理模块的核心，允许您创建和运行新进程。
from multiprocessing import process
def print_numbers():
for i in range(5):
print(i)
p = process(target=print_numbers)
p.start() # starts a new process
p.join() # waits for the process to finish
2. 开始（）
启动进程的活动。
p = process(target=print_numbers) p.start() # runs the target function in a separate process
3. 加入([超时])
阻塞调用进程，直到调用 join() 方法的进程终止。您可以选择指定超时。
p = process(target=print_numbers) p.start() p.join(2) # waits up to 2 seconds for the process to finish
4.is_alive()
如果进程仍在运行，则返回 true。
p = process(target=print_numbers) p.start() print(p.is_alive()) # true if the process is still running
5. 当前进程()
返回表示调用进程的当前 process 对象。
from multiprocessing import current_process
def print_current_process():
print(current_process())
p = process(target=print_current_process)
p.start() # prints the current process info
6.active_children()
返回当前活动的所有 process 对象的列表。
p1 = process(target=print_numbers) p2 = process(target=print_numbers) p1.start() p2.start() print(process.active_children()) # lists all active child processes
7. cpu_count()
返回机器上可用的 cpu 数量。
from multiprocessing import cpu_count print(cpu_count()) # returns the number of cpus on the machine
8. 泳池
pool 对象提供了一种跨多个输入值并行执行函数的便捷方法。它管理一个工作进程池。
from multiprocessing import pool
def square(n):
return n * n
with pool(4) as pool: # pool with 4 worker processes
result = pool.map(square, [1, 2, 3, 4, 5])
print(result) # [1, 4, 9, 16, 25]
9. 队列
队列是一种共享数据结构，允许多个进程通过在它们之间传递数据来进行通信。
from multiprocessing import process, queue
def put_data(q):
q.put([1, 2, 3])
def get_data(q):
data = q.get()
print(data)
q = queue()
p1 = process(target=put_data, args=(q,))
p2 = process(target=get_data, args=(q,))
p1.start()
p2.start()
p1.join()
p2.join()
10. 锁
锁确保一次只有一个进程可以访问共享资源。
from multiprocessing import process, lock
lock = lock()
def print_numbers():
with lock:
for i in range(5):
print(i)
p1 = process(target=print_numbers)
p2 = process(target=print_numbers)
p1.start()
p2.start()
p1.join()
p2.join()
11. 值和数组
value 和 array 对象允许在进程之间共享简单的数据类型和数组。
from multiprocessing import process, value
def increment(val):
with val.get_lock():
val.value += 1
shared_val = value('i', 0)
processes = [process(target=increment, args=(shared_val,)) for _ in range(10)]
for p in processes:
p.start()
for p in processes:
p.join()
print(shared_val.value) # output will be 10
12. 管道
管道提供两个进程之间的双向通信通道。
from multiprocessing import process, pipe
def send_message(conn):
conn.send("hello from child")
conn.close()
parent_conn, child_conn = pipe()
p = process(target=send_message, args=(child_conn,))
p.start()
print(parent_conn.recv()) # receives data from the child process
p.join()
13. 经理
管理器允许您创建多个进程可以同时修改的共享对象，例如列表和字典。
from multiprocessing import process, manager
def modify_list(shared_list):
shared_list.append("new item")
with manager() as manager:
shared_list = manager.list([1, 2, 3])
p = process(target=modify_list, args=(shared_list,))
p.start()
p.join()
print(shared_list) # [1, 2, 3, "new item"]
14. 信号量
信号量允许您控制对资源的访问，一次只允许一定数量的进程访问它。
from multiprocessing import Process, Semaphore
import time
sem = Semaphore(2) # Only 2 processes can access the resource
def limited_access():
with sem:
print("Accessing resource")
time.sleep(2)
processes = [Process(target=limited_access) for _ in range(5)]
for p in processes:
p.start()
for p in processes:
p.join()
结论
python 中的多处理模块旨在充分利用机器上的多个处理器。从使用 process 创建和管理进程，到使用 lock 和 semaphore 控制共享资源，以及通过 queue 和 pipe 促进通信，多处理模块对于 python 应用程序中的并行任务至关重要。
