Python的多进程

fighter_狂奔

已于 2023-10-14 18:47:24 修改

阅读量227

点赞数

分类专栏： python 文章标签： python 开发语言

于 2023-10-12 19:51:01 首次发布

本文链接：https://blog.csdn.net/qq_41304832/article/details/133796002

版权

python 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

两种方法实现多进程

Semaphore

Event（wait、set、clear）

Queue

Pool

Pipe

需要导入multiprocessing库中Process类，例如 from multiprocessing import Process

两种方法实现多进程

1、类继承Process父类，并重写init方法（初始化需要接收的一些属性），run方法（里面编写多进程的业务逻辑），例如：

class MyProcess(Process):
    def __init__(self, num):
        self.num = num
        super().__init__()

    def run(self):
        sum = 0
        for index in range(self.num * 10000000):
            sum += index
        print(f"进程pid={os.getpid()}, 执行完成")

p0 = MyProcess(3)

2、不继承父类Process，直接通过Process类提供的初始化实例方法接收参数，例如

Process（target=<待多进程的方法名>，args=(方法的参数), name=<进程名称>, daemon=<True/False>）

def my_process(num):
    sum = 0
    for index in range(num * 10000000):
        sum += index
    print(f"进程pid={os.getpid()}, 执行完成")

p0 = Process(target=my_process, args=(3,), name='my_process0', daemon=False)
p1 = Process(target=my_process, args=(3,), name='my_process1', daemon=False)

其中daemon 默认值为False表示，父进程完成后程序不会退出，子进程完成后程序才退出。当daemon设置为True后，父进程完成后程序不会等待子进程是否完成并直接退出。

3、选择上面任意一种方式生成process的实例，调用start方法启动多进程 p0.start()

比如用上面1的实现方法调试：

if __name__=="__main__":
    print(f"父进程pid={os.getpid()}")
    p0 = MyProcess(3)
    p1 = MyProcess(3)
    t0 = time.time()
    p0.start()
    p1.start()
    p0.join()
    p1.join()
    t1 = time.time()
    print(f"多进程并发执行时间{t1-t0}s")

注意：p0.join()和p1.join(), 表示线程启动后父进程进入阻塞状态，父进程需要等待子进程完成后才会执行后面的t1 = time.time()语句，如果没有这两句父进程语句（多进程并发执行时间的打印）可能会先执行完成，具体显示效果如下：

#写join语句

父进程pid=5952
进程pid=11444, 执行完成
进程pid=15724, 执行完成
多进程并发执行时间3.627208709716797s

#没有写join语句

父进程pid=16084
多进程并发执行时间0.03003692626953125s
进程pid=5032, 执行完成
进程pid=14344, 执行完成

比如用上面2的实现方法调试（本调试中暂时取消掉join()使用）：

if __name__=="__main__":
    print(f"父进程pid={os.getpid()}")
    p0 = Process(target=my_process, args=(3,), name='my_process0', daemon=False)
    p1 = Process(target=my_process, args=(3,), name='my_process1', daemon=False)
    t0 = time.time()
    p0.start()
    p1.start()
    t1 = time.time()
    print(f"多进程并发执行时间{t1-t0}s")

运行结果：

父进程pid=15276
多进程并发执行时间0.03437018394470215s
进程pid=15296, 执行完成
进程pid=13500, 执行完成

注意当daemon设置为True后，父进程没有join的阻塞继续执行，执行完成后不会等待子进程完成就退出程序，所以子进程的的打印没有执行，打印效果如下：

if __name__=="__main__":
    print(f"父进程pid={os.getpid()}")
    p0 = Process(target=my_process, args=(3,), name='my_process0', daemon=True)
    p1 = Process(target=my_process, args=(3,), name='my_process1', daemon=True)
    t0 = time.time()
    p0.start()
    p1.start()
    t1 = time.time()
    print(f"多进程并发执行时间{t1-t0}s")


父进程pid=13916
多进程并发执行时间0.031133413314819336s

Semaphore

import multiprocessing
import time

from multiprocessing import Process

def samphore_test(s):
    s.acquire()
    print(time.strftime('%H:%M:%S', time.localtime()), multiprocessing.current_process().name + '获得锁')
    time.sleep(2)
    print(time.strftime('%H:%M:%S', time.localtime()), multiprocessing.current_process().name + '释放锁')
    s.release()

if __name__=="__main__":
    s = multiprocessing.Semaphore(1)
    for i in range(4):
        p = multiprocessing.Process(target=samphore_test, args=(s,))
        p.start()

运行结果：

22:17:06 Process-2获得锁
22:17:08 Process-2释放锁
22:17:08 Process-1获得锁
22:17:10 Process-1释放锁
22:17:10 Process-3获得锁
22:17:12 Process-3释放锁
22:17:12 Process-4获得锁
22:17:14 Process-4释放锁

Event（wait、set、clear）

wait方法，进程被阻塞，等待唤醒，wait加参数，表示最多等待多少秒，不加参数表示一直等待

set方法，设置标志位True，wait中的进程被唤醒并执行

clear方法，设置标志位False

import multiprocessing
import time


def worker1(event):
    print("Worker 1 is waiting for the event.")
    event.wait()  # 等待事件被设置为True
    print("Worker 1 received the event and is continuing-1.")
    event.clear()
    event.wait()  # 等待事件第二次被设置为True
    print("Worker 1 received the event and is continuing-2.")

def worker2(event):
    print("Worker 2 is waiting for the event.")
    event.wait()  # 等待事件被设置为True
    print("Worker 2 received the event and is continuing-1.")
    event.clear()
    event.wait()  # 等待事件第二次被设置为True
    print("Worker 2 received the event and is continuing-2.")

if __name__ == '__main__':
    # 创建一个事件对象
    event = multiprocessing.Event()

    # 创建两个进程，传递事件对象作为参数
    process1 = multiprocessing.Process(target=worker1, args=(event,))
    process2 = multiprocessing.Process(target=worker2, args=(event,))

    # 启动进程
    process1.start()
    process2.start()

    time.sleep(5)
    # 模拟一些工作1
    print("Main process is doing some work-1...")
    # 模拟工作后发送事件
    event.set()  # 设置事件为True，通知等待的进程

    time.sleep(2)
    # 模拟一些工作2
    print("Main process is doing some work-2...")
    # 模拟工作后发送事件
    event.set()  # 设置事件为True，通知等待的进程

    # 等待进程完成
    process1.join()
    process2.join()

    print("Main process is done.")

运行结果如下：

Worker 1 is waiting for the event.
Worker 2 is waiting for the event.
Main process is doing some work-1...
Worker 1 received the event and is continuing-1.
Worker 2 received the event and is continuing-1.
Main process is doing some work-2...
Worker 1 received the event and is continuing-2.
Worker 2 received the event and is continuing-2.
Main process is done.

Queue

在 Python 中，multiprocessing 模块提供了 Queue 类，它是用于在多进程之间安全地共享数据的一种方式。Queue 类允许多个进程将数据放入队列（enqueue）或从队列中获取数据（dequeue）而无需担心竞争条件或锁

import time
from multiprocessing import Process, Queue

# 定义一个函数用于将数据放入队列
def producer(q):
    count = 1
    while True:
        q.put(f"Item {count}")
        print(f"生产: Item {count}")
        count += 1
        time.sleep(1)

# 定义一个函数用于从队列中获取数据
def consumer(q):
    while True:
        item = q.get(timeout=1)  # 设置获取数据的超时时间
        print(f"消费: {item}")
        time.sleep(5)

if __name__ == '__main__':
    # 创建一个队列，最大大小为5
    q = Queue(5)

    # 创建生产者进程和消费者进程
    producer_process = Process(target=producer, args=(q,))
    consumer_process = Process(target=consumer, args=(q,))

    # 启动进程
    producer_process.start()
    consumer_process.start()

    # 等待生产者进程完成
    producer_process.join()
    # 等待消费者进程完成
    consumer_process.join()

Pool

multiprocessing.Pool 是 Python 的 multiprocessing 模块中的一个工具，用于创建一个进程池，使你能够在多个进程中并行执行函数。它是一种方便的方式来实现并行计算任务。以下是一个使用 multiprocessing. Pool 的示例（可以看出每次时间点有4个进程同时执行）：

import multiprocessing
import time

# 定义一个函数，用于在进程池中并行执行
def square(x):
    print(f"{time.strftime('%H:%M:%S')} {x}*{x}={x*x}")
    time.sleep(2)

if __name__ == '__main__':
    # 创建一个进程池，设置进程数为4（可以根据需要调整）
    pool = multiprocessing.Pool(processes=4)

    for i in range(1, 10):
        pool.apply_async(func=square, args=(i,))

    pool.close()
    pool.join()


19:28:32 1*1=1
19:28:32 2*2=4
19:28:32 3*3=9
19:28:32 4*4=16
19:28:34 5*5=25
19:28:34 6*6=36
19:28:34 7*7=49
19:28:34 8*8=64
19:28:36 9*9=81

Pipe

Pipe主要用于实现两个进程之间的双向通信，其中一个进程可以向管道写入数据，另一个进程可以从管道读取数据。Pipe在一些特定的应用场景中非常有用，例如父子进程之间的通信。但并不是所有多进程应用都需要使用它。通常，如果只需要简单的单向通信，例如从父进程向子进程发送任务，或从子进程向父进程发送结果，那么 Queue 更容易使用。以下是一个简单的示例，演示如何在多进程中使用 Pipe：

import multiprocessing

# 子进程1函数，接收管道1并向管道2发送数据
import time


def child_process1(conn):
    index = 1
    while True:
        child1_msg = f'child1->child2 message{index}'
        conn.send(child1_msg)
        print(f"process1发送: {child1_msg}")
        data = conn.recv()
        print(f"process1接收: {data}")
        index += 1
        time.sleep(5)

# 子进程2函数，接收管道2并向管道1发送数据
def child_process2(conn):
    index = 1
    while True:
        child2_msg = f'child2->child1 message{index}'
        conn.send(child2_msg)
        print(f"process2发送: {child2_msg}")
        data = conn.recv()
        print(f"process2接收: {data}")
        index += 1
        time.sleep(5)


if __name__ == '__main__':
    # 创建两个管道，分别用于两个子进程之间的通信
    conn1, conn2 = multiprocessing.Pipe()

    # 创建子进程1和子进程2，并传递管道
    p1 = multiprocessing.Process(target=child_process1, args=(conn1,))
    p2 = multiprocessing.Process(target=child_process2, args=(conn2,))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

调试结果

process1发送: child1->child2 message1
process2发送: child2->child1 message1
process1接收: child2->child1 message1
process2接收: child1->child2 message1
process1发送: child1->child2 message2
process2发送: child2->child1 message2
process1接收: child2->child1 message2
process2接收: child1->child2 message2
process1发送: child1->child2 message3
process1接收: child2->child1 message3
process2发送: child2->child1 message3
process2接收: child1->child2 message3
...
...