Python 多处理模块快速指南及示例

本篇文章给大家分享《Python 多处理模块快速指南及示例》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

介绍

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 应用程序中的并行任务至关重要。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。