Python之队列

Python之队列

　　队列：先进先出

　　　　队列与线程有关。

　　　　在多线程编程时，会起到作用。

　　　　作用：确保信息安全的进行交换。

　　　　有get 和 put 方法。

'''

创建一个“队列”对象

import Queue
q = Queue.Queue(maxsize = 10)
Queue.Queue类即是一个队列的同步实现。队列长度可为无限或者有限。可通过Queue的构造函数的可选参数
maxsize来设定队列长度。如果maxsize小于1就表示队列长度无限。

将一个值放入队列中
q.put(10)
调用队列对象的put()方法在队尾插入一个项目。put()有两个参数，第一个item为必需的，为插入项目的值；
第二个block为可选参数，默认为
1。如果队列当前为空且block为1，put()方法就使调用线程暂停,直到空出一个数据单元。如果block为0，
put方法将引发Full异常。

将一个值从队列中取出
q.get()
调用队列对象的get()方法从队头删除并返回一个项目。可选参数为block，默认为True。如果队列为空且
block为True，get()就使调用线程暂停，直至有项目可用。如果队列为空且block为False，队列将引发Empty异常。

'''

 import queue

 #q=queue.Queue(3)  # 默认是  先进先出(FIFO)

 # q.put(111)
 # q.put("hello")
 # q.put(222)
 #
 # q.put(223,False)
 #
 # print(q.get())
 # # print(q.get())
 # # print(q.get())
 # #
 # q.get(False)

 # queue 优点： 线程安全的

 # join和task_done

 # q=queue.Queue(5)

 # q.put(111)
 # q.put(222)
 # q.put(22222)
 #
 #
 # while not q.empty():
 #         a=q.get()
 #         print(a)
 #q.task_done()

 # b=q.get()
 # print(b)
 # q.task_done()

 # q.join()
 #
 # print("ending")

 #  先进后出模式

 # q=queue.LifoQueue()  #  Lifo  last in first out
 #
 #
 # q.put(111)
 # q.put(222)
 # q.put(333)
 #
 # print(q.get())

 # 优先级

 # q=queue.PriorityQueue()
 #
 # q.put([4,"hello4"])
 # q.put([1,"hello"])
 # q.put([2,"hello2"])
 #
 # print(q.get())
 # print(q.get())

 # import queue
 #
 #
 # q=queue.Queue()
 #
 # q.put(111)
 # q.put(2222)
 # q.put(22333)
 #
 # print( )

 #生产者消费者模型

 import time,random
 import queue,threading

 q = queue.Queue()

 def Producer(name):
   count = 0
   while count <10:
     print("making........")
     time.sleep(2)
     q.put(count)
     print('Producer %s has produced %s baozi..' %(name, count))

     count +=1
     #q.task_done()
     #q.join()
     print("ok......")

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

     count +=1

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

 # c2 = threading.Thread(target=Consumer, args=('C',))
 # c3 = threading.Thread(target=Consumer, args=('D',))
 p1.start()
 c1.start()
 # c2.start()
 # c3.start()

　　生产者消费者模型：

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

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

　　这就像，在餐厅，厨师做好菜，不需要直接和客户交流，而是交给前台，而客户去饭菜也不需要不找厨师，直接去前台领取即可，这也是一个结耦的过程。

 import time,random
 import queue,threading

 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 produced %s baozi..' %(name, count))
     count +=1
     #q.task_done()
     #q.join()
     print("ok......")
 def Consumer(name):
   count = 0
   while count <10:
     time.sleep(random.randrange(4))
     if not q.empty():
         data = q.get()
         #q.task_done()
         #q.join()
         print(data)
         print('\033[32;1mConsumer %s has eat %s baozi...\033[0m' %(name, data))
     else:
         print("-----no baozi anymore----")
     count +=1

 p1 = threading.Thread(target=Producer, args=('A',))
 c1 = threading.Thread(target=Consumer, args=('B',))
 # c2 = threading.Thread(target=Consumer, args=('C',))
 # c3 = threading.Thread(target=Consumer, args=('D',))
 p1.start()
 c1.start()
 # c2.start()
 # c3.start()

进程：最小的资源管理单位（盛放线程的容器）

线程：最小的执行单位

Cpython因为存在GIL导致同一时刻同一进程只能有一个线程被执行。

关于setdaemon：程序直到不存在非守护线程时退出！

链接