Python并发编程之三：进程同步、队列和管道

一、进程同步

进程之间是互相独立的，其数据是不共享的，但是它们之间共享一套文件系统或打印系统，所以各进程之间会产生竞争关系，如同时运行多个进程，会造成打印错乱：

from multiprocessing import Process
import time
import os

def work():
    print(f'{os.getpid()} is runing')
    time.sleep(3)
    print(f'{os.getpid()} is end')

if __name__ == '__main__':
    for i in range(3):
        p = Process(target=work)
        p.start()

解释：并发运行，效率高，但竞争同一打印终端，带来了打印错乱，每次打印的顺序都不一致，造成数据不安全。

1、进程加锁

进程加锁处理能有效的控制以上打印错乱的问题：

from multiprocessing import Process,Lock
import time
import os

def work(lock):
    lock.acquire()
    print(f'{os.getpid()} is runing')
    time.sleep(3)
    print(f'{os.getpid()} is end')
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(3):
        p = Process(target=work, args=(lock,))
        p.start()

解释：虽然使用加锁的形式实现了顺序的执行，但是程序又重新变成串行了，这样确实会浪费了时间，却保证了数据的安全。

2、模拟抢票：

# db.txt文件内容未：{"ticket": 3}
from multiprocessing import Process,Lock
import json,time,random

def task(lock):
    lock.acquire()
    dic = json.load(open(r'db.txt'))
    print(f'剩余票数：{dic["ticket"]}')
    dic = json.load(open(r'db.txt'))
    if dic['ticket'] > 0:
        dic['ticket'] -= 1
        time.sleep(random.random())
        json.dump(dic, open(r'db.txt', 'w'))
        print('购票成功！')
    else:
        print('购票失败！')
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    for i in range(5):
        p = Process(target=task, args=(lock,))
        p.start()

输出结果：

剩余票数：3
购票成功！
剩余票数：2
购票成功！
剩余票数：1
购票成功！
剩余票数：0
购票失败！
剩余票数：0
购票失败！

解释：如果不对进程进行加锁操作，有可能造成1张票被多个进程所抢到。

二、队列和管道

加锁可以保证多个进程修改同一块数据时，同一时间只能有一个任务可以进行修改，即串行的修改，但问题是：效率低（共享数据基于文件，而文件是硬盘上的数据）。

因此我们最好找寻一种解决方案能够兼顾：
1、效率高（多个进程共享一块内存的数据）
2、帮我们处理好锁问题。

mutiprocessing 模块为我们提供的基于进程间通信（IPC通信）机制：队列和管道。

1、队列

1、创建队列的类

1. 引入队列 : from multiprocess import Queue,JoinableQueue(继承自Queue,所以可以使用Queue的方法)
2. 创建队列 : Queue([maxsize])：创建共享的进程队列，Queue是多进程安全的队列，可以使用Queue实现多进程之间的数据传递。参数 maxsize 为队列允许的最大对列数，省略则不限制大小。

2、方法介绍

• q.get( biock , timeout ) : 取出队列中的某一项，如果队列为空，此方法将阻塞，知道队列中有东西可取，block用于控制阻塞行为，默认为True，如果设置为False，将不会等待，直接引发Queue.Empty异常， timeout是可选超时时间，用于阻塞，如果在设定的时间间隔内队列内还是没有东西可取，将引发Queue.Empty异常。

• q.get_nowait() : 如果队列为空，不阻塞等待，直接引发Queue.Empty异常。

• q.put(item , block ,timeout) : 将item放入队列，如果队列已满，此方法将阻塞，直到队列中有空间放下，item. block控制阻塞，默认为True，如果设置为False，将引发Queue.Full异常， timeout指定在阻塞模式中等待可用空间的时间长短，超时后将引发Queue.Full异常。

• q.put_nowait() : 如果对列已满，不阻塞等待，直接引发Queue.Full异常.

• q.qsize() : 返回队列目前项目的正确数量。 此函数的结果不可靠，因为再返回结果和在稍后程序中使用结果之间，对列可能添加或删除了某一个项目。

• q.empty() : 判断对列是否为空，如果空返回True。判断结果不可靠，在返回和使用结果之间，对列就有可能已经加入了新的项目。

• q.full() : 判断对列是否已满，如果已满返回True。结果不可靠,理由同上。

• q.close() : 关闭队列，防止队列中加入更多数据。调用此方法，后台线程将继续写入那些已经入队列但尚未写入的数据，但将在此方法完成时马上关闭。如果q被垃圾收集，将调用此方法。关闭队列不会在队列使用者中产生任何类型的数据结束信号或异常。例如，如果某个使用者正在被阻塞在get()操作上，关闭生产者中的队列不会导致get()方法返回错误。

• q.cancel_join_thread()：不会在进程退出时自动连接后台线程。可以防止join_thread()方法阻塞。

• q.join_thread()：连接队列的后台线程。此方法用于在调用q.close()方法之后，等待所有队列项被消耗。默认情况下，此方法由不是q的原始创建者的所有进程调用。调用q.cancel_join_thread方法可以禁止这种行为。

3、代码示例

from multiprocessing import Queue

q = Queue(3)

# 放入
for i in range(3):
    q.put(3)
    print(f'运行放入第{i+1}次，目前队列中的个数：{q.qsize()}')
    print(f'运行取出第{i + 1}次，目前队列是否已满：{"未满" if q.full() == False else "已满"}')
    print(f'运行取出第{i + 1}次，目前队列是否为空：{"未空" if q.empty() == False else "已空"}')

# 取出
for i in range(3):
    q.get(3)
    print(f'运行取出第{i+1}次，目前队列中的个数：{q.qsize()}')
    print(f'运行取出第{i+1}次，目前队列是否已满：{"未满" if q.full() == False else "已满"}')
    print(f'运行取出第{i+1}次，目前队列是否为空：{"未空" if q.empty() == False else "已空"}')

运行结果：

运行放入第1次，目前队列中的个数：1
运行取出第1次，目前队列是否已满：未满
运行取出第1次，目前队列是否为空：已空
运行放入第2次，目前队列中的个数：2
运行取出第2次，目前队列是否已满：未满
运行取出第2次，目前队列是否为空：未空
运行放入第3次，目前队列中的个数：3
运行取出第3次，目前队列是否已满：已满
运行取出第3次，目前队列是否为空：未空
运行取出第1次，目前队列中的个数：2
运行取出第1次，目前队列是否已满：未满
运行取出第1次，目前队列是否为空：未空
运行取出第2次，目前队列中的个数：1
运行取出第2次，目前队列是否已满：未满
运行取出第2次，目前队列是否为空：未空
运行取出第3次，目前队列中的个数：0
运行取出第3次，目前队列是否已满：未满
运行取出第3次，目前队列是否为空：已空

4、生产者消费者模型

1、定义：在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

2、引入原因：在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

3、生产者消费者模型代码一(单个生产者消费者) :

from multiprocessing import Process, Queue
import time, random, os
def consumer(q):
    while True:
        res = q.get()
        if res is None: break  # 收到结束信号则结束
        time.sleep(random.randint(1, 3))
        print(f'吃货{os.getpid()} 吃了 {res}')

def producer(q):
    for i in range(10):
        time.sleep(random.randint(1, 3))
        res = f'包子{i}'
        q.put(res)
        print(f'厨师{os.getpid()} 生产了 {res}')
    q.put(None) # 生产者发送结束信号

if __name__ == '__main__':
    q = Queue()
    #生产者们:即厨师们
    p1 = Process(target=producer, args=(q,))

    #消费者们:即吃货们
    c1 = Process(target=consumer, args=(q,))

    #开始
    p1.start()
    c1.start()

4、生产者消费者模型代码(多个生产者消费者) :

from multiprocessing import Process, Queue
import time, random, os
def consumer(q, name):
    while True:
        res = q.get()
        if res is None: break  # 收到结束信号则结束
        time.sleep(random.randint(1, 3))
        print(f'{name} 吃了 {res}')

def producer(q, name):
    for i in range(2):
        time.sleep(random.randint(1, 3))
        res = f'包子{i}'
        q.put(res)
        print(f'{name} 生产了 {res}')

if __name__ == '__main__':
    q = Queue()
    #生产者们:即厨师们
    p1 = Process(target=producer, args=(q, '厨师1'))
    p2 = Process(target=producer, args=(q, '厨师2'))

    #消费者们:即吃货们
    c1 = Process(target=consumer, args=(q, '吃货1'))
    c2 = Process(target=consumer, args=(q, '吃货2'))

    #开始
    p1.start()
    p2.start()
    c1.start()
    c2.start()

    p1.join()
    p2.join()
    q.put(None)  # 父进程发送结束信号
    q.put(None)  # 父进程发送结束信号

总结：

• 程序中有两类角色：负责生产数据（生产者）、负责处理数据（消费者）
• 引入生产者消费者模型为了解决的问题是：平衡生产者与消费者之间的工作能力，从而提高程序整体处理数据的速度
• 如何实现：生产者<–>队列<——>消费者
• 生产者消费者模型实现类程序的解耦和

2、管道（不推荐使用）

1、创建管道的类

• 引入管道 : from multiprocessing import Pipe
• 创建管道 : Pipe([duplex]):在进程之间创建一条管道，并返回元组（conn1, conn2）,其中conn1，conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道。duplex 默认管道是全双工的，如果将duplex设成False，conn1只能用于接收，conn2只能用于发送。

2、方法介绍

• conn1.recv():接收conn2.send(obj)发送的对象。如果没有消息可接收，recv方法会一直阻塞。如果连接的另外一端已经关闭，那么recv方法会抛出EOFError。

• conn1.send(obj):通过连接发送对象。obj是与序列化兼容的任意对象

• conn1.close():关闭连接。如果conn1被垃圾回收，将自动调用此方法

• conn1.fileno():返回连接使用的整数文件描述符

• conn1.poll([timeout]):如果连接上的数据可用，返回True。timeout指定等待的最长时限。如果省略此参数，方法将立即返回结果。如果将timeout射成None，操作将无限期地等待数据到达。

• conn1.recv_bytes([maxlength]):接收c.send_bytes()方法发送的一条完整的字节消息。maxlength指定要接收的最大字节数。如果进入的消息，超过了这个最大值，将引发IOError异常，并且在连接上无法进行进一步读取。如果连接的另外一端已经关闭，再也不存在任何数据，将引发EOFError异常。

• conn.send_bytes(buffer [, offset [, size]])：通过连接发送字节数据缓冲区，buffer是支持缓冲区接口的任意对象，offset是缓冲区中的字节偏移量，而size是要发送字节数。结果数据以单条消息的形式发出，然后调用c.recv_bytes()函数进行接收

• conn1.recv_bytes_into(buffer [, offset]):接收一条完整的字节消息，并把它保存在buffer对象中，该对象支持可写入的缓冲区接口（即bytearray对象或类似的对象）。offset指定缓冲区中放置消息处的字节位移。返回值是收到的字节数。如果消息长度大于可用的缓冲区空间，将引发BufferTooShort异常。

3、管道的使用

1、主进程向子进程发送信息

from multiprocessing import Pipe, Process

def func(conn1, conn2):
    conn2.close()  # 子进程只需使用connection1,故关闭connection2
    while True:
        try:
            msg = conn1.recv()
            print(msg)
        except EOFError:  # 没收数据接收的时候,才抛出的异常
            conn1.close()
            break

if __name__ == '__main__':
    conn1, conn2 = Pipe() # 建立一个管道,管道返回两个connection
    p = Process(target=func, args=(conn1, conn2))
    p.start()
    conn1.close()  # 主进程只需要一个connection,故关闭一个
    for i in range(10):
        conn2.send(f'第{i}次发送：吃了吗')  # 主进程发送
    conn2.close()  # 主进程关闭connection2

2、生产者消费者模型（管道+锁）

from multiprocessing import Process, Pipe, Lock

def consumer(p, name, lock):
    produce, consume = p
    produce.close()
    while True:
        lock.acquire()
        baozi = consume.recv()
        lock.release()
        if baozi:
            print('%s 收到包子:%s' %(name,baozi))
        else:
            consume.close()
            break


def producer(p, n):
    produce, consume = p
    consume.close()
    for i in range(n):
        produce.send(i)
    produce.send(None)
    produce.send(None)
    produce.close()

if __name__ == '__main__':
    produce, consume = Pipe()
    lock = Lock()
    c1 = Process(target=consumer, args=((produce, consume), 'c1', lock))
    c2 = Process(target=consumer, args=((produce, consume), 'c2', lock))
    p1 = Process(target=producer, args=((produce, consume), 10))
    c1.start()
    c2.start()
    p1.start()

    produce.close()
    consume.close()

    c1.join()
    c2.join()
    p1.join()
    
    print('主进程')

总结：

• 管道有数据不安全性 - 多个消费者同时取一个数据的情况可能发生。
• 管道是双工通信，如果是生产者或消费者中都没有使用管道的某个端点，就应将它关闭。
• 队列是进程数据安全的，因为队列是基于管道加锁实现的。