网站设计大概价格电子商务网站建设多少钱

queue用于建立和操作队列，常和threading类一起用来建立一个简单的线程队列。

首先，队列有很多种，根据进出顺序来分类，可以分成

• queue.Queue(maxsize)　　FIFO（先进先出队列）

• queue.LifoQueue(maxsize)　　LIFO（先进后出队列）

• Queue.PriorityQueue(maxsize)　　为优先级越高的越先出来,对于一个队列中的所有元素组成的entries，优先队列优先返回的一个元素是sorted(list(entries))[0]。至于对于一般的数据，优先队列取什么东西作为优先度要素进行判断，官方文档给出的建议是一个tuple如(priority, data)，取priority作为优先度。

如果设置的maxsize小于1，则表示队列的长度无限长

FIFO是常用的队列，其一些常用的方法有：

• queue.qsize()　　返回队列大小

• queue.empty()　判断队列是否为空

• queue.full()　　判断队列是否满了

• queue.get([block[,timeout]])　从队列头删除并返回一个item，block默认为True，表示当队列为空却去get的时候会阻塞线程，等待直到有有item出现为止来get出这个item。如果是False的话表明当队列为空你却去get的时候，会引发异常。在block为True的情况下可以再设置timeout参数。表示当队列为空，get阻塞timeout指定的秒数之后还没有get到的话就引发Full异常。

• queue.put(...[,block[,timeout]])　　向队尾插入一个item，同样若block=True的话队列满时就阻塞等待有空位出来再put，block=False时引发异常。同get的timeout，put的timeout是在block为True的时候进行超时设置的参数。

• queue.task_done()　从场景上来说，处理完一个get出来的item之后，调用task_done将向队列发出一个信号，表示本任务已经完成

• queue.join()　监视所有item并阻塞主线程，直到所有item都调用了task_done之后主线程才继续向下执行。这么做的好处在于，假如一个线程开始处理最后一个任务，它从任务队列中拿走最后一个任务，此时任务队列就空了但最后那个线程还没处理完。当调用了join之后，主线程就不会因为队列空了而擅自结束，而是等待最后那个线程处理完成了。

import queue      #  线程 队列q=queue.Queue(3)  # FIFO模式q.put(12)
q.put("hello")
q.put({"name":"yuan"})print(q.qsize())
print(q.empty())
print(q.full())while 1:data=q.get()print(data)print("----------")
#打印#
# 3
# False
# True
# 12
# ----------
# hello
# ----------
# {'name': 'yuan'}
# ----------

class queue.Queue(maxsize=0) #先进先出

import queueq=queue.Queue()
q.put('first')
q.put('second')
q.put('third')print(q.get())
print(q.get())
print(q.get())
'''
结果(先进先出):
first
second
third
'''

#encoding: utf-8from queue import Queue
import time
import threading# q = Queue(4)
#
# for x in range(4):
#     q.put(x)
#
# for x in range(4):
#     print(q.get())def set_value(q):index = 0while True:q.put(index)index += 1time.sleep(3)def get_value(q):while True:print(q.get())def main():q = Queue(4)t1 = threading.Thread(target=set_value,args=[q])t2 = threading.Thread(target=get_value,args=[q])t1.start()t2.start()if __name__ == '__main__':main()

class queue.LifoQueue(maxsize=0) #last in fisrt out

import queueq=queue.LifoQueue()
q.put('first')
q.put('second')
q.put('third')print(q.get())
print(q.get())
print(q.get())
'''
结果(后进先出):
third
second
first
'''

class queue.PriorityQueue(maxsize=0) #存储数据时可设置优先级的队列

import queueq=queue.PriorityQueue()
#put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
q.put((20,'a'))
q.put((10,'b'))
q.put((30,'c'))print(q.get())
print(q.get())
print(q.get())
'''
结果(数字越小优先级越高,优先级高的优先出队):
(10, 'b')
(20, 'a')
(30, 'c')
'''

生产者 消费者模式

生产者消费者模型

在并发编程中使用生产者和消费者模式能够解决绝大多数并发问题。该模式通过平衡生产线程和消费线程的工作能力来提高程序的整体处理数据的速度。

为什么要使用生产者和消费者模式

在线程世界里，生产者就是生产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果生产者处理速度很快，而消费者处理速度很慢，那么生产者就必须等待消费者处理完，才能继续生产数据。同样的道理，如果消费者的处理能力大于生产者，那么消费者就必须等待生产者。为了解决这个问题于是引入了生产者和消费者模式。

什么是生产者消费者模式

生产者消费者模式是通过一个容器来解决生产者和消费者的强耦合问题。生产者和消费者彼此之间不直接通讯，而通过阻塞队列来进行通讯，所以生产者生产完数据之后不用等待消费者处理，直接扔给阻塞队列，消费者不找生产者要数据，而是直接从阻塞队列里取，阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。

基于队列实现生产者消费者模型

from multiprocessing import Process,JoinableQueue
import time,random,os
def consumer(q):while True:res=q.get()time.sleep(random.randint(1,3))print('\033[45m%s 吃 %s\033[0m' %(os.getpid(),res))q.task_done() #向q.join()发送一次信号,证明一个数据已经被取走了def producer(name,q):for i in range(10):time.sleep(random.randint(1,3))res='%s%s' %(name,i)q.put(res)print('\033[44m%s 生产了 %s\033[0m' %(os.getpid(),res))q.join()if __name__ == '__main__':q=JoinableQueue()#生产者们:即厨师们p1=Process(target=producer,args=('包子',q))p2=Process(target=producer,args=('骨头',q))p3=Process(target=producer,args=('泔水',q))#消费者们:即吃货们c1=Process(target=consumer,args=(q,))c2=Process(target=consumer,args=(q,))c1.daemon=Truec2.daemon=True#开始p_l=[p1,p2,p3,c1,c2]for p in p_l:p.start()p1.join()p2.join()p3.join()print('主') #主进程等--->p1,p2,p3等---->c1,c2#p1,p2,p3结束了,证明c1,c2肯定全都收完了p1,p2,p3发到队列的数据#因而c1,c2也没有存在的价值了,应该随着主进程的结束而结束,所以设置成守护进程

#JoinableQueue([maxsize])：这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

参数介绍：
maxsize是队列中允许最大项数，省略则无大小限制。
方法介绍：
JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：

• q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
• q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止

生产者消费者模型总结

#程序中有两类角色一类负责生产数据（生产者）一类负责处理数据（消费者）#引入生产者消费者模型为了解决的问题是：平衡生产者与消费者之间的工作能力，从而提高程序整体处理数据的速度#如何实现：生产者<-->队列<——>消费者
#生产者消费者模型实现类程序的解耦和