Python_queue单项队列

　　队列（queue），实现程序间的松耦合

队列的三种类：

• class queue.Queue(maxsize)# 先进先出, maxsize 指定队列长度，线程安全的清况下，可以放入实例，对实例进行传输
• class queue.LifoQueue(maxsize) # 后进先出（栈）
• class queue.PriorityQueue(maxsize) # 存储数据是可设置优先级的队列

每个类都有相似的方法：

q.qsize()	返回队列的个数
q.empty()	判断队列是否为空
q.full()	判断队列是否填满了
q.put(item,block = True, timeout = None)	把数据放入一个队列，队列满的时候阻塞了，用timeout限定时间，超过时间报异常，否则队列一直等着.
q.get()	拿出队列内的元素，
q.put_nowait()	如果队列满了直接不等待，抛异常
q.get_nowait()	如果队列里没有东西，直接抛异常
q.task_done()	在生产者-消费者模型中队列作为一个传送带，次方法如一个信号

import queue

q = queue.Queue()

q.put([32,None,'hello'])
q.put([45,34,77])
print(q.qsize())
print(q.empty())
print(q.full())
print('\n')
print(q.get())   # 队列按照先进先出
for i in q.get():
    print(i)

例：example

2
False
False

[32, None, 'hello']
45
34
77

result

其中：

1. exception queue.Empty    #get()阻塞 ，get_nowait()非阻塞抛此异常
2. exception queue.Full   #put()等待, put_nowait()   给queue设置长度时，队列满则抛此异常

注：在PriorityQueue()中，put的时候有两个参数((优先级，数值),timeout=None)（优先级1>10）

import queue
q = queue.PriorityQueue(maxsize=3)

q.put((1,19))
q.put((10,[34, ]),timeout=2)
q.put((4,[32,None,'hello']))
print(q.qsize())
print(q.full())
print(q.get())   # 队列按照先进先出
print(q.get())   # 队列按照先进先出
print(q.get())   # 队列按照先进先出

例：PriorityQueue

3
True
(1, 19)
(4, [32, None, 'hello'])
(10, [34])

result

多线程基于Queue的生产者--消费者模型：

import queue,threading
import time
def consumer(n):
    while True:
        print('消费者[%s]号吃掉了包子：【%s】'%(n,q.get()))
        time.sleep(1)
        q.task_done()   # **通知队列吃完一个，全都吃完啦，然后才通知生产者

def producer(n):
    count = 1
    while True:
        time.sleep(0.5)
        if q.qsize()<3:
            print('生产者[%s]生产一个新的包子：【%s】'%(n,count))
            q.put(count)
            count += 1
            q.join()     # 等待队列的通知
            print('所有的包子都被吃完啦。。')

q = queue.Queue()
for i in range(3):   # 消费者
    c = threading.Thread(target=consumer,args=[i,])
    c.start()
for i in range(5):   # 生产者
    p = threading.Thread(target=producer,args=['Presley',])
    p.start()

生产者_消费者模型

生产者[Presley]生产一个新的包子：【1】
消费者[0]号吃掉了包子：【1】
生产者[Presley]生产一个新的包子：【1】
消费者[1]号吃掉了包子：【1】
生产者[Presley]生产一个新的包子：【1】
消费者[2]号吃掉了包子：【1】
生产者[Presley]生产一个新的包子：【1】
生产者[Presley]生产一个新的包子：【1】
消费者[0]号吃掉了包子：【1】
消费者[1]号吃掉了包子：【1】
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
生产者[Presley]生产一个新的包子：【2】
生产者[Presley]生产一个新的包子：【2】
生产者[Presley]生产一个新的包子：【2】
消费者[2]号吃掉了包子：【2】
消费者[0]号吃掉了包子：【2】
生产者[Presley]生产一个新的包子：【2】
消费者[1]号吃掉了包子：【2】
生产者[Presley]生产一个新的包子：【2】
消费者[2]号吃掉了包子：【2】
消费者[1]号吃掉了包子：【2】
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
生产者[Presley]生产一个新的包子：【3】
生产者[Presley]生产一个新的包子：【3】
生产者[Presley]生产一个新的包子：【3】
消费者[1]号吃掉了包子：【3】
消费者[0]号吃掉了包子：【3】
生产者[Presley]生产一个新的包子：【3】
消费者[2]号吃掉了包子：【3】
生产者[Presley]生产一个新的包子：【3】
消费者[2]号吃掉了包子：【3】
消费者[0]号吃掉了包子：【3】
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
所有的包子都被吃完啦。。
生产者[Presley]生产一个新的包子：【4】
消费者[1]号吃掉了包子：【4】
生产者[Presley]生产一个新的包子：【4】
消费者[2]号吃掉了包子：【4】
生产者[Presley]生产一个新的包子：【4】
消费者[0]号吃掉了包子：【4】
生产者[Presley]生产一个新的包子：【4】
生产者[Presley]生产一个新的包子：【4】
.
.
.
.
....

result