当前位置:Gxlcms > Python > Queue模块及源码分析

Queue模块及源码分析

时间:2021-07-01 10:21:17 帮助过:21人阅读

Queue模块是提供队列操作的模块,队列是线程间最常用的交换数据的形式。该模块提供了三种队列:

Queue.Queue(maxsize):先进先出,maxsize是队列的大小,其值为非正数时为无线循环队列

Queue.LifoQueue(maxsize):后进先出,相当于栈

Queue.PriorityQueue(maxsize):优先级队列。

其中LifoQueue,PriorityQueue是Queue的子类。三者拥有以下共同的方法:

qsize():返回近似的队列大小。为什么要加“近似”二字呢?因为当该值大于0的时候并不保证并发执行的时候get()方法不被阻塞,同样,对于put()方法有效。

empty():返回布尔值,队列为空时,返回True,反之返回False。

full():当设定了队列大小的时候,如果队列满了,则返回True,否则返回False。

put(item[,block[,timeout]]):向队列里添加元素item,block设置为False的时候,如果队列满了则抛出Full异常。如果block设置为True,timeout设置为None时,则会一种等到有空位的时候再添加进队列;否则会根据timeout设定的超时值抛出Full异常。

put_nowwait(item):等价与put(item,False)。block设置为False的时候,如果队列为空,则抛出Empty异常。如果block设置为True,timeout设置为None时,则会一种等到有空位的时候再添加进队列;否则会根据timeout设定的超时值抛出Empty异常。

get([block[,timeout]]):从队列中删除元素并返回该元素的值,如果timeout是一个正数,它会阻塞最多超时秒数,并且如果在该时间内没有可用的项目,则引发Empty异常。

get_nowwait():等价于get(False)

task_done():发送信号表明入列任务已完成,经常在消费者线程中用到。

join():阻塞直至队列所有元素处理完毕,然后再处理其它操作。

(一)源码分析

Queue模块用起来很简单很简单,但我觉得有必要把该模块的相关源代码贴出来分析下,会学到不少东西,看看大神们写的代码多么美观,多么结构化模块化,再想想自己写的代码,都是泪呀,来学习学习。为了缩减篇幅,源码的注释部分被删减掉。

  1. from time import time as _time
  2. try:
  3. import threading as _threading
  4. except ImportError:
  5. import dummy_threading as _threading
  6. from collections import deque
  7. import heapq
  8. __all__ = ['Empty', 'Full', 'Queue', 'PriorityQueue', 'LifoQueue']
  9. class Empty(Exception):
  10. "Exception raised by Queue.get(block=0)/get_nowait()."
  11. pass
  12. class Full(Exception):
  13. "Exception raised by Queue.put(block=0)/put_nowait()."
  14. pass
  15. class Queue:
  16. def __init__(self, maxsize=0):
  17. self.maxsize = maxsize
  18. self._init(maxsize)
  19. self.mutex = _threading.Lock()
  20. self.not_empty = _threading.Condition(self.mutex)
  21. self.not_full = _threading.Condition(self.mutex)
  22. self.all_tasks_done = _threading.Condition(self.mutex)
  23. self.unfinished_tasks =
  24. def get_nowait(self):
  25. return self.get(False)
  26. def _init(self, maxsize):
  27. self.queue = deque()
  28. def _qsize(self, len=len):
  29. return len(self.queue)
  30. def _put(self, item):
  31. self.queue.append(item)
  32. def _get(self):
  33. return self.queue.popleft()

通过后面的几个函数分析知道,Queue对象是在collections模块的queue基础上(关于collections模块参考 Python:使用Counter进行计数统计及collections模块),加上threading模块互斥锁和条件变量封装的。

deque是一个双端队列,很适用于队列和栈。上面的Queue对象就是一个先进先出的队列,所以首先_init()函数定义了一个双端队列,然后它的定义了_put()和_get()函数,它们分别是从双端队列右边添加元素、左边删除元素,这就构成了一个先进先出队列,同理很容易想到LifoQueue(后进先出队列)的实现了,保证队列右边添加右边删除就可以。可以贴出源代码看看。

  1. class LifoQueue(Queue):
  2. '''Variant of Queue that retrieves most recently added entries first.'''
  3. def _init(self, maxsize):
  4. self.queue = []
  5. def _qsize(self, len=len):
  6. return len(self.queue)
  7. def _put(self, item):
  8. self.queue.append(item)
  9. def _get(self):
  10. return self.queue.pop()

虽然它的"queue"没有用queue(),用列表也是一样的,因为列表append()和pop()操作是在最右边添加元素和删除最右边元素。

再来看看PriorityQueue,他是个优先级队列,这里用到了heapq模块的heappush()和heappop()两个函数。heapq模块对堆这种数据结构进行了模块化,可以建立这种数据结构,同时heapq模块也提供了相应的方法来对堆做操作。其中_init()函数里self.queue=[]可以看作是建立了一个空堆。heappush() 往堆中插入一条新的值 ,heappop() 从堆中弹出最小值 ,这就可以实现优先级(关于heapq模块这里这是简单的介绍)。源代码如下:

  1. class PriorityQueue(Queue):
  2. '''Variant of Queue that retrieves open entries in priority order (lowest first).
  3. Entries are typically tuples of the form: (priority number, data).
  4. '''
  5. def _init(self, maxsize):
  6. self.queue = []
  7. def _qsize(self, len=len):
  8. return len(self.queue)
  9. def _put(self, item, heappush=heapq.heappush):
  10. heappush(self.queue, item)
  11. def _get(self, heappop=heapq.heappop):
  12. return heappop(self.queue)

基本的数据结构分析完了,接着分析其它的部分。

mutex 是个threading.Lock()对象,是互斥锁;not_empty、 not_full 、all_tasks_done这三个都是threading.Condition()对象,条件变量,而且维护的是同一把锁对象mutex(关于threading模块中Lock对象和Condition对象可参考上篇博文Python:线程、进程与协程(2)——threading模块)。

其中:

self.mutex互斥锁:任何获取队列的状态(empty(),qsize()等),或者修改队列的内容的操作(get,put等)都必须持有该互斥锁。acquire()获取锁,release()释放锁。同时该互斥锁被三个条件变量共同维护。

self.not_empty条件变量:线程添加数据到队列中后,会调用self.not_empty.notify()通知其它线程,然后唤醒一个移除元素的线程。

self.not_full条件变量:当一个元素被移除出队列时,会唤醒一个添加元素的线程。

self.all_tasks_done条件变量 :在未完成任务的数量被删除至0时,通知所有任务完成

self.unfinished_tasks : 定义未完成任务数量


再来看看主要方法:

(1)put()

源代码如下:

  1. def put(self, item, block=True, timeout=None):
  2. self.not_full.acquire() #not_full获得锁
  3. try:
  4. if self.maxsize > 0: #如果队列长度有限制
  5. if not block: #如果没阻塞
  6. if self._qsize() == self.maxsize: #如果队列满了抛异常
  7. raise Full
  8. elif timeout is None: #有阻塞且超时为空,等待
  9. while self._qsize() == self.maxsize:
  10. self.not_full.wait()
  11. elif timeout < 0:
  12. raise ValueError("'timeout' must be a non-negative number")
  13. else: #如果有阻塞,且超时非负时,结束时间=当前时间+超时时间
  14. endtime = _time() + timeout
  15. while self._qsize() == self.maxsize:
  16. remaining = endtime - _time()
  17. if remaining <= 0.0: #到时后,抛异常
  18. raise Full
  19. #如果没到时,队列是满的就会一直被挂起,直到有“位置”腾出
  20. self.not_full.wait(remaining)
  21. self._put(item) #调用_put方法,添加元素
  22. self.unfinished_tasks += 1 #未完成任务+1
  23. self.not_empty.notify() #通知非空,唤醒非空挂起的任务
  24. finally:
  25. self.not_full.release() #not_full释放锁

默认情况下block为True,timeout为None。如果队列满则会等待,未满则会调用_put方法将进程加入deque中(后面介绍),并且未完成任务加1还会通知队列非空。

如果设置block参数为Flase,队列满时则会抛异常。如果设置了超时那么在时间到之前进行阻塞,时间一到抛异常。这个方法使用not_full对象进行操作。

(2)get()

源码如下:

  1. def get(self, block=True, timeout=None):
  2. self.not_empty.acquire() #not_empty获得锁
  3. try:
  4. if not block: #不阻塞时
  5. if not self._qsize(): #队列为空时抛异常
  6. raise Empty
  7. elif timeout is None: #不限时时,队列为空则会等待
  8. while not self._qsize():
  9. self.not_empty.wait()
  10. elif timeout < 0:
  11. raise ValueError("'timeout' must be a non-negative number")
  12. else:
  13. endtime = _time() + timeout
  14. while not self._qsize():
  15. remaining = endtime - _time()
  16. if remaining <= 0.0:
  17. raise Empty
  18. self.not_empty.wait(remaining)
  19. item = self._get() #调用_get方法,移除并获得项目
  20. self.not_full.notify() #通知非满
  21. return item #返回项目
  22. finally:
  23. self.not_empty.release() #释放锁

逻辑跟put()函数一样,参数默认情况下队列空了则会等待,否则将会调用_get方法(往下看)移除并获得一个项,最后返回这个项。这个方法使用not_empty对象进行操作。

不过我觉得put()与get()两个函数结合起来理解比较好。not_full与not_empty代表的是两种不同操作类型的线程,not_full可以理解成is-not-full,即队列是否满了,默认是没有满,没有满时not_full这个条件变量才能获取锁,并做一些条件判断,只有符合条件才能向队列里加元素,添加成功后就会通知not_empty条件变量队列里不是空的,“我”刚刚添加进了一个元素,满足可以执行删除动作的基本条件了(队列不是空的,想想如果是空的执行删除动作就没有意义了),同时唤醒一些被挂起的执行移除动作的线程,让这些线程重新判断条件,如果条件准许就会执行删除动作,然后又通知not_full条件变量,告诉“它”队列不是满的,因为“我”刚才删除了一个元素(想想如果队列满了添加元素就添加不进呀,就没意义了),满足了添加元素的基本条件(队列不是满的),同时唤醒一些被挂起的执行添加动作的线程,这些线程又会进行条件判断,符合条件就会添加元素,否则继续挂起,依次类推,同时这样也保证了线程的安全。正与前面所说,当一个元素被移除出队列时,会唤醒一个添加元素的线程;当添加一个元素时会唤醒一个删除元素的线程。

(3)task_done()

源码如下:

  1. def task_done(self):
  2. self.all_tasks_done.acquire() #获得锁
  3. try:
  4. unfinished = self.unfinished_tasks - 1 #判断队列中一个线程的任务是否全部完成
  5. if unfinished <= 0: #是则进行通知,或在过量调用时报异常
  6. if unfinished < 0:
  7. raise ValueError('task_done() called too many times')
  8. self.all_tasks_done.notify_all()
  9. self.unfinished_tasks = unfinished #否则未完成任务数量-1
  10. finally:
  11. self.all_tasks_done.release() #最后释放锁

这个方法判断队列中一个线程的任务是否全部完成,首先会通过all_tasks_done对象获得锁,如果是则进行通知,最后释放锁。


(4)join()

源码如下:

  1. def join(self):
  2. self.all_tasks_done.acquire()
  3. try:
  4. while self.unfinished_tasks: #如果有未完成的任务,将调用wait()方法等待
  5. self.all_tasks_done.wait()
  6. finally:
  7. self.all_tasks_done.release()

阻塞方法,当队列中有未完成进程时,调用join方法来阻塞,直到他们都完成。


其它的方法都比较简单,也比较好理解,有兴趣可以去看看Queue.py里的源码,要注意的是任何获取队列的状态(empty(),qsize()等),或者修改队列的内容的操作(get,put等)都必须持有互斥锁mutex。

(二)简单例子

实现一个线程不断生成一个随机数到一个队列中

实现一个线程从上面的队列里面不断的取出奇数

实现另外一个线程从上面的队列里面不断取出偶数

  1. import random,threading,time
  2. from Queue import Queue
  3. is_product = True
  4. class Producer(threading.Thread):
  5. """生产数据"""
  6. def __init__(self, t_name, queue):
  7. threading.Thread.__init__(self,name=t_name)
  8. self.data=queue
  9. def run(self):
  10. while 1:
  11. if self.data.full():
  12. global is_product
  13. is_product = False
  14. else:
  15. if self.data.qsize() <= 7:#队列长度小于等于7时添加元素
  16. is_product = True
  17. for i in range(2): #每次向队列里添加两个元素
  18. randomnum=random.randint(1,99)
  19. print "%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), randomnum)
  20. self.data.put(randomnum,False) #将数据依次存入队列
  21. time.sleep(1)
  22. print "deque length is %s"%self.data.qsize()
  23. else:
  24. if is_product:
  25. for i in range(2): #
  26. randomnum = random.randint(1, 99)
  27. print "%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), randomnum)
  28. self.data.put(randomnum,False) # 将数据依次存入队列
  29. time.sleep(1)
  30. print "deque length is %s" % self.data.qsize()
  31. else:
  32. pass
  33. print "%s: %s finished!" %(time.ctime(), self.getName())
  34. #Consumer thread
  35. class Consumer_even(threading.Thread):
  36. def __init__(self,t_name,queue):
  37. threading.Thread.__init__(self,name=t_name)
  38. self.data=queue
  39. def run(self):
  40. while 1:
  41. if self.data.qsize() > 7:#队列长度大于7时开始取元素
  42. val_even = self.data.get(False)
  43. if val_even%2==0:
  44. print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(),self.getName(),val_even)
  45. time.sleep(2)
  46. else:
  47. self.data.put(val_even)
  48. time.sleep(2)
  49. print "deque length is %s" % self.data.qsize()
  50. else:
  51. pass
  52. class Consumer_odd(threading.Thread):
  53. def __init__(self,t_name,queue):
  54. threading.Thread.__init__(self, name=t_name)
  55. self.data=queue
  56. def run(self):
  57. while 1:
  58. if self.data.qsize() > 7:
  59. val_odd = self.data.get(False)
  60. if val_odd%2!=0:
  61. print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(), self.getName(), val_odd)
  62. time.sleep(2)
  63. else:
  64. self.data.put(val_odd)
  65. time.sleep(2)
  66. print "deque length is %s" % self.data.qsize()
  67. else:
  68. pass
  69. #Main thread
  70. def main():
  71. queue = Queue(20)
  72. producer = Producer('Pro.', queue)
  73. consumer_even = Consumer_even('Con_even.', queue)
  74. consumer_odd = Consumer_odd('Con_odd.',queue)
  75. producer.start()
  76. consumer_even.start()
  77. consumer_odd.start()
  78. producer.join()
  79. consumer_even.join()
  80. consumer_odd.join()
  81. if __name__ == '__main__':
  82. main()

人气教程排行