队列-Queue

Queue：

　　Python中，队列是线程间最常用的交换数据的形式。Queue模块是提供队列操作的模块。

Python queue模块有三种队列及构造函数:

　　1、class queue.Queue(maxsize) 　　　　 　　 - queue模块的FIFO队列先进先出。
　　2、class queue.LifoQueue(maxsize) 　　 　　 - LIFO类似于堆，即先进后出。
　　3、class queue.PriorityQueue(maxsize)　　 　- 是可以设置优先级的队列，设置数值越低越先出来。

创建一个队列：

1、class queue.Queue(maxsize) 

import queue

q = queue.Queue(maxsize = 0) # 无限或者有限,通过构造函数的默认参数 maxsize 来设置队列长度，maxsize 小于1就表示队列长度无限。

for i in range(10):
　　 # put() 将 i 依次从队尾插入队列 [ q ] 中,
　　 # put(item,block=True,timeout=None) 第二个参数block默认为True，当为 False时 ，如果q.qsize() > q.maxsize 就会引发 full的异常
　　 # timeout 为等待时间，如果等待时间内，队列没有空出位置插入元素，则会触发full的异常
    q.put(i)

for j in range(1,q.qsize()+1):
    # get()删除并返回一个项目。可选参数为block，默认为True。如果队列为空且block为True，get()就使调用线程暂停，直至有元素可用。
    # 如果队列为空且block为False，队列将引发Empty异常。
    # qsize() 是用来获取当前队列中的元素个数
    print('获取的第%d值为：[ %d ],队列中还剩下  %d 个元素'% (j, q.get(),q.qsize()))


>>>
    获取的第1值为：[ 0 ],队列中还剩下  9 个元素
    获取的第2值为：[ 1 ],队列中还剩下  8 个元素
    获取的第3值为：[ 2 ],队列中还剩下  7 个元素
    获取的第4值为：[ 3 ],队列中还剩下  6 个元素
    获取的第5值为：[ 4 ],队列中还剩下  5 个元素
    获取的第6值为：[ 5 ],队列中还剩下  4 个元素
    获取的第7值为：[ 6 ],队列中还剩下  3 个元素
    获取的第8值为：[ 7 ],队列中还剩下  2 个元素
    获取的第9值为：[ 8 ],队列中还剩下  1 个元素
    获取的第10值为：[ 9 ],队列中还剩下  0 个元素

2、class queue.LifoQueue(maxsize)

import queue

q = queue.LifoQueue()

for i in range(10):
    # put() 将 i 依次从队尾插入队列 [ q ] 中
    q.put(i)

for j in range(1,q.qsize()+1):
    #遵循先进后出原则。
    print('获取的第%d值为：[ %d ],队列中还剩下  %d 个元素'% (j, q.get(),q.qsize()))


>>>
    获取的第1值为：[ 9 ],队列中还剩下  9 个元素
    获取的第2值为：[ 8 ],队列中还剩下  8 个元素
    获取的第3值为：[ 7 ],队列中还剩下  7 个元素
    获取的第4值为：[ 6 ],队列中还剩下  6 个元素
    获取的第5值为：[ 5 ],队列中还剩下  5 个元素
    获取的第6值为：[ 4 ],队列中还剩下  4 个元素
    获取的第7值为：[ 3 ],队列中还剩下  3 个元素
    获取的第8值为：[ 2 ],队列中还剩下  2 个元素
    获取的第9值为：[ 1 ],队列中还剩下  1 个元素
    获取的第10值为：[ 0 ],队列中还剩下  0 个元素    

3、class queue.PriorityQueue(maxsize)

q = queue.PriorityQueue()

# for i in range(10):
    # put() 将 i 依次从队尾插入队列 [ q ] 中

q.put((2,'Tom'))
q.put((3,'AK'))
q.put((1,'alex'))

for j in range(1,q.qsize()+1):
    # 遵循优先级排列输出
    print(q.get())

>>>
    (1, 'alex')
    (2, 'Tom')
    (3, 'AK')

Queue方法：

q.qsize() # 返回队列的大小
q.empty() # 如果队列为空，返回True,反之False
q.full() # 如果队列满了，返回True,反之False
q.full  #maxsize 大小对应
q.get([block[, timeout]])  #获取队列，timeout等待时间
q.get_nowait()  # 相当q.get(False)
q.put(item) # 写入队列，timeout等待时间 非阻塞 
q.put_nowait(item) # 相当q.put(item, False)
q.task_done() # 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号
q.join() # 实际上意味着等到队列为空，再执行别的操作

Queue 实例：

　　

import threading,queue,time
q = queue.Queue(maxsize=10)

def Producer(name):
    count = 1
    while True:
        q.put('包子')
        print('%s生产包子%d个' % (name, count))
        count+=1
        time.sleep(0.4)
def Consumer(name):
    count = 0
    while True:
        count += 1
        q.get()
        print(' [%s]吃了 %d 个%s'%(name,count,q.get()))
        time.sleep(1)
t1 = threading.Thread(target=Producer,args=('alex',))
t2 = threading.Thread(target=Consumer,args=('Tom',))

t1.start()
t2.start()
>>>
    alex生产包子1个
    alex生产包子2个
     [Tom]吃了 1 个包子
    alex生产包子3个
    alex生产包子4个
     [Tom]吃了 2 个包子
    alex生产包子5个
    alex生产包子6个。。。。

 线程池：

# 简单往队列中传输线程数
import threading
import time
import queue

class Threadingpool():
    def __init__(self,max_num = 10):
        self.queue = queue.Queue(max_num)
        for i in range(max_num):
            self.queue.put(threading.Thread)

    def getthreading(self):
        return self.queue.get()

    def addthreading(self):
        self.queue.put(threading.Thread)


def func(p,i):
    time.sleep(1)
    print(i)
    p.addthreading()


if __name__ == "__main__":
    p = Threadingpool()
    for i in range(20):
        thread = p.getthreading()
        t = thread(target = func, args = (p,i))
        t.start()