python------生产者消费者模型和管道

一、为什么要使用生产者和消费者？

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

二、什么是生产者消费者模式

　　生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

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('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))

def producer(q):

    for i in range(10):

        time.sleep(random.randint(1,3))

        res='包子%s' %i

        q.put(res)

        print('\033[44m%s 生产了 %s\033[0m' %(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()

    print('主')

基于队列实现生产者消费者模型

注意：结束信号None，不一定要由生产者发，主进程里同样可以发，但主进程需要等生产者结束后才应该发送该信号

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('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))

def producer(q):

    for i in range(2):

        time.sleep(random.randint(1,3))

        res='包子%s' %i

        q.put(res)

        print('\033[44m%s 生产了 %s\033[0m' %(os.getpid(),res))

if __name__ == '__main__':

    q=Queue()

    #生产者们:即厨师们

    p1=Process(target=producer,args=(q,))

    #消费者们:即吃货们

    c1=Process(target=consumer,args=(q,))

    #开始

    p1.start()

    c1.start()

    p1.join()

    q.put(None) #发送结束信号

    print('主')

主进程在生产者生产完毕后发送结束信号None

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('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))

def producer(name,q):

    for i in range(2):

        time.sleep(random.randint(1,3))

        res='%s%s' %(name,i)

        q.put(res)

        print('\033[44m%s 生产了 %s\033[0m' %(os.getpid(),res))

if __name__ == '__main__':

    q=Queue()

    #生产者们:即厨师们

    p1=Process(target=producer,args=('包子',q))

    p2=Process(target=producer,args=('骨头',q))

    p3=Process(target=producer,args=('泔水',q))

    #消费者们:即吃货们

    c1=Process(target=consumer,args=(q,))

    c2=Process(target=consumer,args=(q,))

    #开始

    p1.start()

    p2.start()

    p3.start()

    c1.start()

    p1.join() #必须保证生产者全部生产完毕,才应该发送结束信号

    p2.join()

    p3.join()

    q.put(None) #有几个消费者就应该发送几次结束信号None

    q.put(None) #发送结束信号

    print('主')

多个消费者的例子：有几个消费者就需要发送几次结束信号

三、管道

创建管道的类：

　　Pipe([]duplex):在进程之间创建一条管道，并返回元组（conn1,conn2）,其中conn1,conn2表示管道两端的连接对象，强调一点：必须在产生Process对象之前产生管道

参数：

　　duplex:默认管道是全双工的，如果将duplex设成False,conn1只能用于接收，conn2只能用于发送。

主要方法：

　　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()函数进行接收。

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

应该特别注意管道端点的正确管理问题：如果生产者或者消费者中都没有使用管道的某个端点，就应将它关闭。这也说明了为何在生产者中关闭了管道的输出端，在消费者中关闭了管道的输入端。

from multiprocessing import Process,Pipe

def consumer(p,name):

    produce, consume=p

    produce.close()

    while True:

        try:

            baozi=consume.recv()

            print('%s 收到包子:%s' %(name,baozi))

        except EOFError:

            break

def producer(seq,p):

    produce, consume=p

    consume.close()

    for i in seq:

        produce.send(i)

if __name__ == '__main__':

    produce,consume=Pipe()

    c1=Process(target=consumer,args=((produce,consume),'c1'))

    c1.start()

    seq=(i for i in range(10))

    producer(seq,(produce,consume))

    produce.close()

    consume.close()

    c1.join()

    print('主进程')

pipe实现生产者消费者模型

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('主进程')

多个消费之之间的竞争问题带来的数据不安全问题

四、数据之间的数据共享

　　通过使用线程，推荐做法也是将程序设计为大量独立的线程集合，通过消息队列交换数据。这样极大地减少了对使用锁定和其他同步手段的需求，还可以扩展到分布式系统中。但进程间应该尽量避免通信，即使需要通信，也应该选择进程安全的工具来避免加锁带来的问题。

　　进程间数据是独立的，可以借助于队列或管道实现通信，二者都是基于消息传递的。虽然进程间数据独立，但可以通过Manager实现数据共享，事实上Manager的功能远不止于此。

from multiprocessing import Manager,Process,Lock

def work(d,lock):

    with lock: #不加锁而操作共享的数据,肯定会出现数据错乱

        d['count']-=1

if __name__ == '__main__':

    lock=Lock()

    with Manager() as m:

        dic=m.dict({'count':100})

        p_l=[]

        for i in range(100):

            p=Process(target=work,args=(dic,lock))

            p_l.append(p)

            p.start()

        for p in p_l:

            p.join()

        print(dic)

Manager

巴特西

python------生产者消费者模型和管道

最新文章

热门文章

巴特西

python------生产者消费者模型 和 管道

最新文章

热门文章

python------生产者消费者模型和管道