目录
需要导入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
...
...