生产者-消费者问题与quene模块

生产者-消费者问题与quene模块

下面使用线程锁以及队列来模拟一个典型的案例：生产者-消费者模型。在这个场景下，商品或服务的生产者生产商品，然后将其放到类似队列的数据结构中，生产商品的时间是不确定的，

同样消费者消费生产者的商品的时间也是不确定的。

这里使用quene模块来提供线程间通信的机制，也就是说，生产者和消费者共享一个队列。生产者生产商品后，会将商品添加到队列中。消费者消费商品，会从队列中取出一个商品。

由于向队列中添加商品和从队列中获取商品都不是原子操作，所以需要使用线程锁将这两个操作锁住。

本例使用线程锁和队列实现了一个生产者和消费者模型的程序。通过for循环产生若干个生产者和消费者，并向队列中添加商品，以及从队列中获取商品

实例：

from random import randrange
from time import sleep,time,ctime
from threading import Thread,Lock
from queue import Queue
#创建线程锁对象
lock=Lock()
#从Thread类派生的子类
class MyThread(Thread):
    def __init__(self,func,args):
        super().__init__(target=func,args=args)
#向队列中添加商品
def writeQ(queue):
    #获取线程锁
    lock.acquire()
    print('生产一个对象，并将其添加到队列中',end=' ')
    #向队列中添加商品
    queue.put('商品')
    print('队列商品',queue.qsize())
    #释放线程锁
    lock.release()
#从队列中获取商品
def readQ(queue):
    #获取线程锁
    lock.acquire()
    #从队列中获取商品
    val=queue.get(1)
    print('消费了一个对象，队列尺寸：',queue.qsize())
    #释放线程锁
    lock.release()
#生产若干个上产者
def writer(queue,loops):
    for i in range(loops):
        writeQ(queue)
        sleep(randrange(1,4))
#生成若干个消费者
def reader(queue,loops):
    for i in range(loops):
        readQ(queue)
        sleep(randrange(2,6))
funcs=[writer,reader]
nfuncs=range(len(funcs))

def main():
    nloops=randrange(2,6)
    q=Queue(32)

    thread=[]
    #创建2个线程运行writer函数和reader函数
    for i in nfuncs:
        t=MyThread(funcs[i],(q,nloops))
        thread.append(t)
    #开始线程
    for i in nfuncs:
        thread[i].start()
    #等待2个线程结束
    for i in nfuncs:
        thread[i].join()
    print('所有工作完成')
if __name__ == '__main__':
    main()

E:\python\python.exe E:/progect/untitled1/untitled1/urls.py
生产一个对象，并将其添加到队列中 队列商品 1
消费了一个对象，队列尺寸： 0
生产一个对象，并将其添加到队列中 队列商品 1
生产一个对象，并将其添加到队列中 队列商品 2
消费了一个对象，队列尺寸： 1
消费了一个对象，队列尺寸： 0
所有工作完成