Python队列（queue)

队列是一种常见的数据结构，在python作为一个单独的模块存在。

python支持以下几种队列：

• FIFO队列，先进先出队列，对象为queue.Queue
• 无界FIFO 队列，对象为queue.SimpleQueue
• LIFO队列，后进先出队列，对象为queue.LifoQueue
• 优先级队列，对象为queue.PriorityQueue

FIFO队列

class queue.Queue(maxsize=0)

FIFO即First in First Out,先进先出。Queue提供了一个基本的FIFO容器，使用方法很简单,maxsize是个整数，指明了队列中能存放的数据个数的上限。一旦达到上限，插入会导致阻塞，直到队列中的数据被消费掉。如果maxsize小于或者等于0，队列大小没有限制。

import queue

q = queue.Queue()
for i in range(5):
    q.put(i)

while not q.empty():
    print q.get()

主要方法和属性

方法和属性名	说明
Queue.qsize()	返回队列的大致大小。注意，qsize() > 0 不保证后续的 get() 不被阻塞，qsize() < maxsize 也不保证 put() 不被阻塞。
Queue.empty()	如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。
Queue.full()	如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。
Queue.put(item, block=True, timeout=None)	将一个元素放入队列中，如果队列满，block为True，将等待最多timeout秒
Queue.put_nowait(item)	相当于 put(item, block=False)。
Queue.get(block=True, timeout=None)	从队列中移除并返回一个元素。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。
Queue.get_nowait()	相当于 get(False) 。
Queue.task_done()	表示前面排队的任务已经被完成。被队列的消费者线程使用。每个 get() 被用于获取一个任务， 后续调用 task_done() 告诉队列，该任务的处理已经完成。 如果 join() 当前正在阻塞，在所有条目都被处理后，将解除阻塞(意味着每个 put() 进队列的条目的 task_done() 都被收到)。 如果被调用的次数多于放入队列中的项目数量，将引发 ValueError 异常 。
Queue.join()	阻塞至队列中所有的元素都被接收和处理完毕。

import threading
import queue

q = queue.Queue()

def worker():
    while True:
        item = q.get()
        print(f'Working on {item}')
        print(f'Finished {item}')
        q.task_done()

# Turn-on the worker thread.
threading.Thread(target=worker, daemon=True).start()

# Send thirty task requests to the worker.
for item in range(30):
    q.put(item)

# Block until all tasks are done.
q.join()
print('All work completed')

SimpleQueue 对象

无界的 FIFO 队列构造函数。简单的队列，缺少任务跟踪等高级功能，task_done()和join()方法没有，其他的与Queue完全一样。

LIFO队列

class queue.LifoQueue(maxsize=0)

LIFO 队列构造函数。 maxsize 是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零，队列尺寸为无限大。

属性和方法与FIFO的Queue对象一样。

import queue


class Job(object):
    def __init__(self, priority, description):
        self.priority = priority
        self.description = description
        print('Job:',description)


    def __lt__(self, other):
        return self.priority < other.priority


if __name__ == '__main__':
    q = queue.LifoQueue()

    q.put(Job(1, 'level 1 job'))
    q.put(Job(2, 'level 2 job'))
    q.put(Job(3, 'level 3 job'))

    while not q.empty():
        job = q.get_nowait()
        print('get():', job.description)


‘’’
Job: level 1 job
Job: level 2 job
Job: level 3 job
get(): level 3 job
get(): level 2 job
get(): level 1 job
’‘’

优先队列

class queue.PriorityQueue(maxsize=0)

优先级队列构造函数。 maxsize 是个整数，用于设置可以放入队列中的项目数的上限。当达到这个大小的时候，插入操作将阻塞至队列中的项目被消费掉。如果 maxsize 小于等于零，队列尺寸为无限大。

属性和方法与FIFO的Queue对象一样。

如果 data 元素没有可比性，数据将被包装在一个类中，忽略数据值，仅仅比较优先级数字 ：

import queue


class Job(object):
    def __init__(self, priority, description):
        self.priority = priority
        self.description = description
        print('Job:',description)


    def __lt__(self, other):
        return self.priority < other.priority


if __name__ == '__main__':
    q = queue.PriorityQueue()

    q.put(Job(3, 'level 3 job'))
    q.put(Job(10, 'level 10 job'))
    q.put(Job(1, 'level 1 job'))

    while not q.empty():
        job = q.get_nowait()
        print('get():', job.description)


‘’'
Job: level 3 job
Job: level 10 job
Job: level 1 job
get(): level 1 job
get(): level 3 job
get(): level 10 job
‘''