生产者消费者问题

下面是生产者消费者问题

生产者-消费者问题和Queue/queue模块

  • 生产者生产商品,将商品放入到类似队列的数据结构中,生产的时间不确定

  • 消费者消费商品,消费的时间不确定

  • 使用Queue模块创建队列,生产者线程放入商品,消费者线程消费商品

  • 下表列出Queue/queue模块的常用属性

  • 属性 描述
    Queue/queue模块的类 ******
    Queue(maxsize=0) 创建一个先进先出队列,若给定最大值,则当队列没有空间时阻塞,否则为无限队列
    LifoQueue(maxsize=0) 创建一个后进先出队列,若给定最大值,则空间满时阻塞,否则为无限队列
    PriorityQueue(maxsize=0) 创建一个优先级队列,若给定最大值,当没有空间时阻塞,否则为无限队列
    Queue/queue异常
    Empty 当对空队列调用get*()方法时抛出的异常
    Full 当对已满的队列调用put*()方法是抛出的异常
    Queue/queue对象方法
    qsize() 返回队列大小(该值为近似值)
    empty() 若队列为空,返回True,否则返回False
    full() 若队列为满,返回True,否则为False
    put(item,block=True,timeout=None) 将item放入队列,如果block为True且timeout=None,则在有可用之前阻塞,如果timeout为正值,则最多阻塞timeout秒,block=False,则抛出Empty异常
    put_nowait(item) 和put(item,False)一样
    get(block=True,timeout=None) 从队列中获得元素,若给定block则一直阻塞到有可用的元素为止
    get_nowait() 和get(False)相同
    task_done() 用于表示队列中的某个元素已执行完成,该方法会被下面的join()使用
    join() 在队列中所有元素执行完毕并调用上面的task_done信号之前,保持阻塞

  • 生产者消费者问题

    from time import sleep,ctime
    import threading
    
    loops=(4,2)
    
    class MyThread(threading.Thread):
        def __init__(self,func,args,name=''):
            threading.Thread.__init__(self)
            self.func=func
            self.args=args
            self.name=name
    
        def run(self):
            return self.func(*self.args)
    
    def loop(nloop,nsec):
        print("loop {} started at {} ".format(nloop,ctime()))
        sleep(nsec)
        print("loop {} started at {} ".format(nloop,ctime()))
    
    def main():
        print("Main started at {}".format(ctime()))
        threads=[]
        count=range(len(loops))
    
        for i in count:
            t=MyThread(loop,(i,loops[i]),loop.__name__)
            threads.append(t)
    
        for i in count:
            threads[i].start()
    
        for i in count:
            threads[i].join()
    
        print("All done at {}".format(ctime()))
    
    if __name__ == '__main__':
        main()
        
    #——————————————上述为自定义的MyTread类,下面为生产者消费者问题——————————————————————
    from time import ctime,sleep
    from random import randint
    from e import MyThread
    from queue import Queue
    
    def writeQ(queue):  #将生产的对象放入队列中
        print("Producing Q")
        queue.put("xxx",1)
        print("size now {}".format(queue.qsize()))
    
    def readQ(queue):   #消费在队列中的对象
        print("consuming Q size now  {}".format(queue.qsize()))
        val=queue.get(1)
    
    def write(queue,loops):  #根据loops生产随机数量的对象
        for i in (range(loops)):
            writeQ(queue)
            sleep(randint(1,3))
    
    def read(queue,loops):   #根据loops消费随机数量的对象
        for i in range(loops):
            readQ(queue)
            sleep(randint(2,5))
    
    funcs=[write,read]
    nfuncs=range(len(funcs))
    
    def main():
        nloops=randint(2,5)  #设置进行的随机次数
        threads=[]
        q=Queue(32)  #设置最大队列
        for i in nfuncs:
            t=MyThread(funcs[i],(q,nloops),funcs[i].__name__)
            threads.append(t)
    
        for i in nfuncs:
            threads[i].start()
    
        for i in nfuncs:
            threads[i].join()
    
        print("All Done!!!")
    
    if __name__ == '__main__':
        main()
        
    '''显示结果如下:
    func write run at Sat May 23 08:19:39 2020
    Producing Q
    size now 1
    func read run at Sat May 23 08:19:39 2020
    consuming Q size now  1
    Producing Q
    size now 1
    Producing Q
    size now 2
    consuming Q size now  2
    func write finished at Sat May 23 08:19:46 2020
    consuming Q size now  1
    func read finished at Sat May 23 08:19:51 2020
    All Done!!!'''
    
    
    • 注意不管是生产还是消费,每次只生产或消费一个对象
    • 注意到write对象的暂停时间较短保证了消费时尽可能的可以拥有消费对象,而不是从空队列中取值

上述就是生产者消费者问题,希望对各位有所帮助!

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 1024 设计师: 上身试试
应支付0元
点击重新获取
扫码支付

支付成功即可阅读