介绍
python 中的多处理模块允许您创建和管理进程，使您能够充分利用机器上的多个处理器。它通过为每个进程使用单独的内存空间来帮助您实现并行执行，这与线程共享相同内存空间的线程不同。以下是多处理模块中常用的类和方法的列表，并附有简短的示例。
1. 流程
process 类是多处理模块的核心，允许您创建和运行新进程。
1
2
3
4
5
6
7
8
9
from multiprocessing import process
def print_numbers():
for i in range(5):
print(i)
p = process(target=print_numbers)
p.start() # starts a 编程网点我wcqh.cnnew process
p.join() # waits for the process to finish
2. 开始（）
启动进程的活动。
1
2
p = process(target=print_numbers)
p.start() # runs the target function in a separate process
3. 加入([超时])
阻塞调用进程，直到调用 join() 方法的进程终止。您可以选择指定超时。
1
2
3
p = process(target=print_numbers)
p.start()
p.join(2) # waits up to 2 second编程网点我wcqh.cns for the process to finish
4.is_alive()
如果进程仍在运行，则返回 true。
1
2
3
p = process(target=print_numbers)
p.start()
print(p.is_alive()) # true if the process is still running
5. 当前进程()
返回表示调用进程的当前 process 对象。
1
2
3
4
5
6
7
from multiprocessing import current_process
def print_current_process():
print(current_proce编程网点我wcqh.cnss())
p = process(target=print_current_process)
p.start() # prints the current process info
6.active_children()
返回当前活动的所有 process 对象的列表。
1
2
3
4
5
6
p1 = process(target=print_numbers)
p2 = process(target=print_numbers)
p1.start()
p2.start()
print(process.active_children()) # lists all active child processes编程网点我wcqh.cn
7. cpu_count()
返回机器上可用的 cpu 数量。
1
2
3
from multiprocessing import cpu_count
print(cpu_count()) # returns the number of cpus on the machine
8. 泳池
pool 对象提供了一种跨多个输入值并行执行函数的便捷方法。它管理一个工作进程池。
1
2
3
4
5
6
7
8
9
from multiprocessing import pool
def square(n):
return n * n
with pool(4) as pool: # pool with 4 worker 编程网点我wcqh.cnprocesses
result = pool.map(square, [1, 2, 3, 4, 5])
print(result) # [1, 4, 9, 16, 25]
9. 队列
队列是一种共享数据结构，允许多个进程通过在它们之间传递数据来进行通信。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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编程网点我wcqh.cn=put_data, args=(q,))
p2 = process(target=get_data, args=(q,))
p1.start()
p2.start()
p1.join()
p2.join()
10. 锁
锁确保一次只有一个进程可以访问共享资源。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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 =编程网点我wcqh.cn process(target=print_numbers)
p1.start()
p2.start()
p1.join()
p2.join()
11. 值和数组
value 和 array 对象允许在进程之间共享简单的数据类型和数组。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from multiprocessing import process, value
def increment(val):
with val.get_lock():
val.value += 1
shared_val = value(i, 0)
processes = [process(target=increment, ar编程网点我wcqh.cngs=(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. 管道
管道提供两个进程之间的双向通信通道。
1
2
3
4
5
6
7
8
9
10
11
12
from multiprocessing import process, pipe
def send_message(conn):
conn.send(“hello from child”)
conn.close()
parent_conn, ch编程网点我wcqh.cnild_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. 经理
管理器允许您创建多个进程可以同时修改的共享对象，例如列表和字典。
1
2
3
4
5
6
7
8
9
10
11
12
13
from multiprocessing import process, manager
def modify_list(shared_list):
shared_list.appe编程网点我wcqh.cnnd(“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. 信号量
信号量允许您控制对资源的访问，一次只允许一定数量的进程访问它。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from multiprocessing import Process, Semaph编程网点我wcqh.cnore
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 中的多处理模块旨在充分利用机器上的多个处理器。编程网点我wcqh.cn从使用 process 创建和管理进程，到使用 lock 和 semaphore 控制共享资源，以及通过 queue 和 pipe 促进通信，多处理模块对于 python 应用程序中的并行任务至关重要。
以上就是Python 多处理模块快速指南及示例的详细内容，更多请关注青狐资源网其它相关文章！
会员专属
暂无评论内容