python -- 进程之 Event进程同步、队列Queue、Pool进程池、数据交换Pipe

一、Event – 进程同步

• Event 是用来实现进程同步的

1.应用场景演示

• e = multiprocessing.Event() 生成了一个Event对象e
• e.wait() 等待，如果不被唤醒，将一直阻塞，不往下执行。
• e.wait(arg) 传入超时时间参数，超时后自动唤醒，执行后面代码
• e.set() 唤醒Event的wait() 等待状态，继续执行下面的代码
• e.clear() 利用clear()可以清除Event当前的set()唤醒状态，之后遇到wait()会继续等待。

import multiprocessing
import time

def wait_for_event(e):
    e.wait()
    time.sleep(1)

    # 唤醒后接触Event状态，之后继续等待
    e.clear()
    print(f"{time.strftime('%Y-%m-%d %H:%M:%S')} 进程A : 我们是兄弟，我在里面等你")
    e.wait()
    print(f"{time.strftime('%Y-%m-%d %H:%M:%S')} 进程A : 我们出发 ")

def wait_for_event_tomrout(e, i):
    e.wait()
    time.sleep(1)
    # 唤醒后接触Event状态，之后继续等待
    e.clear()
    print(f"{time.strftime('%Y-%m-%d %H:%M:%S')} 进程B : 我最多等你{i}秒")
    e.wait(i)          # wait(3) 传入参数，表示等待3秒，超时后自动唤醒并往下执行
    print(f"{time.strftime('%Y-%m-%d %H:%M:%S')} 进程B : 我先走了")

if __name__ == '__main__':
    e = multiprocessing.Event()
    w1 = multiprocessing.Process(target=wait_for_event, args=(e,))
    w2 = multiprocessing.Process(target=wait_for_event_tomrout, args=(e, 3))
    w1.start()
    w2.start()
    # 主进程发话
    print(f'{time.strftime("%Y-%m-%d %H:%M:%S")} 主进程 : 先别动手，等我准备一下，需要8s时间 ')

    # 唤醒等待的进程
    e.set()
    time.sleep(8)
    print(f'{time.strftime("%Y-%m-%d %H:%M:%S")} 主进程 : ok,我来了 ')

    # 再次唤醒被等待的进程
    e.set()
    w1.join()
    w2.join()
    print(f'{time.strftime("%Y-%m-%d %H:%M:%S")} 主进程 : GO')

执行结果：

2021-05-19 10:12:24 主进程 : 先别动手，等我准备一下，需要8s时间 

2021-05-19 10:12:25 进程A : 我们是兄弟，我在里面等你
2021-05-19 10:12:25 进程B : 我最多等你3秒

2021-05-19 10:12:28 进程B : 我先走了

2021-05-19 10:12:32 主进程 : ok,我来了 
2021-05-19 10:12:32 进程A : 我们出发 
2021-05-19 10:12:32 主进程 : GO

Process finished with exit code 0

二、Queue – 优先级队列

1、了解Queue队列

• Queue 是多进程安全的队列，可以使用 Queue 实现多进程之间的数据传递
  • put() 方法：用于插入数据到队列中，常用的两个参数 — blocked 和 timeout
    • blocked=True ：如果设置为True(默认值)，并且 timeout为正值，则该方法会阻塞timeout指定的时间，直到队列有剩余空间。若超时对列依旧没有剩余空间，才会抛出Queue.Full 的异常
    • blocked=False：如果设置为False。一旦该对列Queue已满，则会立即抛出Queue.Full 的异常。
  • get() 方法：同样有两个可选参数 blocked 和 tomeout。
    • blocked=True ：如果blocked为True(默认值)，并且 timeout 为正值，在等待时间内没有取到任何元素，则会抛出 Queue.Empty 异常。
    • blocked=False：如果 blocked为False，那么会出现两种情况，Queue有一个值可用，会立即返回该值；否则队列为空，立即抛出Queue.Empty 异常。

示例

from multiprocessing import Process,Queue
import time
def Producer_A(q):
    ''' 生产者模型 '''
    count = 1
    while 1:
        q.put(f"食品-{count}")
        print(f"{time.strftime('%H:%M:%S')} A 放入食品-{count}")
        count += 1
        time.sleep(1)

def Consumer_B(q):
    while 1:
        '''消费者模型'''
        print(f"{time.strftime('%H:%M:%S')} B 取出食品-{q.get()}")
        time.sleep(3)

if __name__ == '__main__':
    q = Queue(maxsize=5)      # maxsize=5，队列中对多可用存放的消息数
    p_a = Process(target=Producer_A, args=(q,))
    p_b = Process(target=Consumer_B, args=(q,))
    p_a.start()
    p_b.start()
    p_b.join()
    p_a.join()

执行结果：

14:13:02 A 放入食品-1
14:13:02 B 取出食品-食品-1
14:13:03 A 放入食品-2
14:13:04 A 放入食品-3
14:13:05 A 放入食品-4
14:13:05 B 取出食品-食品-2
14:13:06 A 放入食品-5
14:13:07 A 放入食品-6
14:13:08 A 放入食品-7
14:13:08 B 取出食品-食品-3
14:13:09 A 放入食品-8
14:13:11 B 取出食品-食品-4
14:13:11 A 放入食品-9
14:13:14 B 取出食品-食品-5
14:13:14 A 放入食品-10
……

三、进程池–Pool

• pool = multiprocessing.Pool(processes=3) ：定义一个进程池大小，并发执行的进程数小于等于池大小。pool = multiprocessing.Pool(3)效果一样
  示例

import multiprocessing
import time

def task(name):
    print(f"{time.strftime('%H:%M:%S')} : {name}  开始执行")
    time.sleep(2)

if __name__ == '__main__':
    # pool = multiprocessing.Pool(processes=3)
    pool = multiprocessing.Pool(3)
    for i in range(1, 11):
        # 维持执行的进程总数为processes，当一个进程执行完毕后会添加新的进程进去
        pool.apply_async(func=task, args=(i,))
    pool.close()
    pool.join()

执行结果：

14:36:40 : 1  开始执行
14:36:40 : 2  开始执行
14:36:40 : 3  开始执行

14:36:42 : 4  开始执行
14:36:42 : 5  开始执行
14:36:42 : 6  开始执行

14:36:44 : 7  开始执行
14:36:44 : 8  开始执行
14:36:44 : 9  开始执行

14:36:46 : 10  开始执行

Process finished with exit code 0

四、多进程之数据交换 – Pipe

1.了解Pipe

我们在Unix系统中经常使用一条命令的输出(STDOUT)作为林一条命令的输入(STDIN)获取最终的结果。在python中多进程变成中也有一个pipe方法可以实现多进程之间的数据传输。

示例图：

• multiprocess.Pipe()方法：返回一个管道的两个端口，
  • 如Command1 的STDOUT 和 Command2 的 STDIN，这样Command1的输出就会作为Command2的输入。
  • 如果反过来，让Command2 的输出也可以作为 Command1 的输入，这就是全双工管道，默认也是全双工管道。
  • 如果想设置成半双工管道，只需要给Pipe()方法传递 duplex=False参数就可以了，即Pipe(duplex=False)
• Pipe()方法返回的对象具有发送消息 send()的方法 和 接收消息recv()的方法，可以调用Command1.send(msg)来发送消息，调用Command2.recv()来接收消息。
• 如果没有消息可以接收，recv()方法会一直阻塞。如果管道已经关闭，recv()方法会抛出EOFError异常

2.应用示例

import multiprocessing
import time

def task1(pipe):
    for i in range(5):
        str = f"task1-{i}"
        print(f"{time.strftime('%H:%M:%S')} task1 发送 : {str}")
        pipe.send(str)
    time.sleep(2)
    for i in range(5):
        print(f"{time.strftime('%H:%M:%S')} task1 接收 : {pipe.recv()}")

def task2(pipe):
    for i in range(5):
        print(f"{time.strftime('%H:%M:%S')} task2 接收 : {pipe.recv()}")

    time.sleep(1)
    for i in range(5):
        str = f"task2-{i}"
        print(f"{time.strftime('%H:%M:%S')} task2 发送 : {str}")
        pipe.send(str)

if __name__ == '__main__':
    pipe = multiprocessing.Pipe()
    # pipe[0] 和 pipe[1] 可以看出管道的两端。pipe的两端最好只各对应一个进程
    p1 = multiprocessing.Process(target=task1, args=(pipe[0],))
    p2 = multiprocessing.Process(target=task2, args=(pipe[1],))

    p1.start()
    p2.start()

    p1.join()
    p2.join()

执行结果

16:28:10 task1 发送 : task1-0
16:28:10 task1 发送 : task1-1
16:28:10 task1 发送 : task1-2
16:28:10 task1 发送 : task1-3
16:28:10 task2 接收 : task1-0
16:28:10 task1 发送 : task1-4
16:28:10 task2 接收 : task1-1
16:28:10 task2 接收 : task1-2
16:28:10 task2 接收 : task1-3
16:28:10 task2 接收 : task1-4

16:28:11 task2 发送 : task2-0
16:28:11 task2 发送 : task2-1
16:28:11 task2 发送 : task2-2
16:28:11 task2 发送 : task2-3
16:28:11 task2 发送 : task2-4

16:28:12 task1 接收 : task2-0
16:28:12 task1 接收 : task2-1
16:28:12 task1 接收 : task2-2
16:28:12 task1 接收 : task2-3
16:28:12 task1 接收 : task2-4

Process finished with exit code 0