线程队列

队列：相对于列表来说，保证了数据的安全

#队列

#先进先出
import queue   #线程队列

q = queue.Queue(3)   #创建一个队列，参数设置队列中最多能有多少个元素,超过则阻塞直至等到线程get出数据

q.put(12)   #向队列中添加值，两个参数，第一个参数是添加的值
q.put("hello")
q.put({"name":"ss"})
q.put(22,False)   #put第二个参数，设置成False时，当queue满了时，不会阻塞等待，而抛出一个异常

while True:
    data = q.get(block=False)  
　　#获取并删除队列中的值,参数默认为True，且队列为空参数为True时，阻塞等待线程put数据，当设置成False时直接抛出异常
    print(data)

#后进先出
import queue

q = queue.LifoQueue()

q.put(12)   #向队列中添加值
q.put("hello")
q.put({"name":"ss"})
q.put(22,False)

while True:
    data = q.get()  
    print(data)

#优先级
import queue

q = queue.PriorityQueue()   #按照优先级

q.put([3,12])     #参数为列表格式，第一个是级别，数字越低，优先级越高，第二个是值
q.put([2,"hello"])
q.put([4,{"name":"ss"}])

while True:
    data = q.get()
    print(data)

队列的一些其他方法

q.qsize()           #qsize队列中有多少个值
q.empty()           #检测队列是否为空，空返回True，反之，返回False
q.full()            #检测队列是否满了，满了则返回True，否则返回False
q.put_nowait(22)    #相当于put(item,False)
q.get_nowait()      #相当于get(block=False)
q.task_done()       #当完成一项操作时，可以向队列发送一个信号，由join接收
q.join()            #相当于当队列为空时，再执行别的操作

生产者消费者模型

　　给生产者和消费者之间加一个容器用来解除他们之间的强耦合性，生产者和消费者之间不直接通信，

　　而是通过阻塞队列进行通信，生产者生产好之后，不必等待消费者，而是直接将数据给阻塞队列，消费者也是直接从队列中拿数据

import time,random
import threading,queue

q = queue.Queue()

def Producer(name):
    count = 0
    while count<10:
        print("making....")
        time.sleep(random.randrange(3))
        q.put(count)
        print("Producer %s has producer %s food" %(name,count))
        count += 1
        q.task_done()
        print("ok")

def Consumer(name):
    count = 0
    while count<10:
        time.sleep(random.randrange(4))
        if not q.empty():
            data = q.get()
            q.join()
            print("\033[32;1mConsumer %s has eat %s food\033[0m" %(name,data))
        else:
            print("no food anymore")
        count += 1

p1 = threading.Thread(target=Producer,args=("A",))
c1 = threading.Thread(target=Consumer,args=("B",))

p1.start()
c1.start()