queue队列模块

1 基本理解

　　Queue是一个在内存中，元素带顺序的容器。

　　解耦：数据待处理线程把数据交给队列，不需要关心处理者是谁。处理者从队列中拿数据处理，不和待处理线程接触。

　　效率：数据待处理线程把数据交给队列，然后继续自己的工作。处理者可以多线程并发处理。

　　和列表的区别：队列中的数据取出就会消失。列表不会。

　　队列中的元素，处理顺序有三种，先入先出，后入先出，优先级。

2 class queue.Queue() 

first in first out

import  queue

q = queue.Queue()
q.put('d1')
q.put('d2')
print(q.qsize())
q.get()
q.get()
q.get(block=True,timeout=4)
>>
2
    raise Empty
queue.Empty
#创建队列实例，put两个数据，获取列队长度，get数据。
#get方法默认阻塞，超时为None，qsize为0时持续阻塞。
#get不到数据，超时后，抛出一个队列空的异常

import  queue
q = queue.Queue(maxsize=5)
q.put('d1',timeout=4)
q.put('d1',timeout=4)
q.put('d1',timeout=4)
q.put('d1',timeout=4)
q.put('d1',timeout=4)

q.put('d1',timeout=4)
>>
    raise Full
queue.Full
#创建队列实例时设定了size，然后put方法中设定了timeout，size满了，put超时，就抛出队列满的异常

　　

3 class queue.LifoQueue

last in first out

import  queue

q = queue.LifoQueue()
q.put('d1')
q.put('d2')
print(q.qsize())
print(q.get())
print(q.get())
>>
2
d2
d1

　　

4 queue.PriorityQueue()

。。。

5 生产消费者模型

import  queue,threading,time

q = queue.Queue(maxsize=100)

def producer(name,speed):
    count = 0
    while True:
        count += 1
        q.put('骨头%s' %(count))
        print('33[42m现在的骨头数 %s,生产者为%s33[0m' %(q.qsize(),name))
        time.sleep(speed)

def customer(name,speed):
    while True:
        print('%s 消费 %s,正在吃...' %(name,q.get()))
        time.sleep(speed)

jabbok = threading.Thread(target=producer,args=('jabbok',2.5,))
eric = threading.Thread(target=producer,args=('eric',1.5,))
vici = threading.Thread(target=customer,args=('vici',2,))
lee = threading.Thread(target=customer,args=('lee',3,))
jabbok.start()
eric.start()
vici.start()
lee.start()
#jabbok和eric为生产者，jabbok每2.5秒生产一块骨头，eric每1.5秒生产一块骨头
#vici和lee为消费者，vici每2s吃一块骨头，lee每3s吃一块骨头
#生产者生产的骨头放入队列，队列最多放100块骨头。消费者从队列买骨头。实现解耦。