生产者-消费者问题与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

所有工作完成