Python Queue模块详解

Python中，队列是线程间最常用的交换数据的形式。Queue模块是提供队列操作的模块，虽然简单易用，但是不小心的话，还是会出现一些意外。

创建一个“队列”对象

from  queue  import  Queue#进程内非阻塞队列

from multiprocessing  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异常。

Python Queue模块有三种队列及构造函数:
1、Python Queue模块的FIFO队列先进先出。 class Queue.Queue(maxsize)
2、LIFO类似于堆，即先进后出。 class Queue.LifoQueue(maxsize)
3、还有一种是优先级队列级别越低越先出来。 class Queue.PriorityQueue(maxsize)

此包中的常用方法(q = 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() 实际上意味着等到队列为空，再执行别的操作

timeout 默认为None，一直等，如果设置时间N秒，则会等待N秒

block  默认True  --阻塞（停止在put/get状态），直到put/get进去为止

范例：
实现一个线程不断生成一个随机数到一个队列中(考虑使用Queue这个模块)
实现一个线程从上面的队列里面不断的取出奇数
实现另外一个线程从上面的队列里面不断取出偶数

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

#!/usr/bin/env python #coding:utf8 import random,threading,time from Queue import Queue #Producer thread class Producer(threading.Thread):   def __init__(self, t_name, queue):     threading.Thread.__init__(self,name=t_name)     self.data=queue   def run(self):     for i in range(10):  #随机产生10个数字 ，可以修改为任意大小       randomnum=random.randint(1,99)       print "%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), randomnum)       self.data.put(randomnum) #将数据依次存入队列       time.sleep(1)     print "%s: %s finished!" %(time.ctime(), self.getName())    #Consumer thread class Consumer_even(threading.Thread):   def __init__(self,t_name,queue):     threading.Thread.__init__(self,name=t_name)     self.data=queue   def run(self):     while 1:       try:         val_even = self.data.get(1,5) #get(self, block=True, timeout=None) ,1就是阻塞等待,5是超时5秒         if val_even%2==0:           print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(),self.getName(),val_even)           time.sleep(2)         else:           self.data.put(val_even)           time.sleep(2)       except:   #等待输入，超过5秒 就报异常         print "%s: %s finished!" %(time.ctime(),self.getName())         break class Consumer_odd(threading.Thread):   def __init__(self,t_name,queue):     threading.Thread.__init__(self, name=t_name)     self.data=queue   def run(self):     while 1:       try:         val_odd = self.data.get(1,5)         if val_odd%2!=0:           print "%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(), self.getName(), val_odd)           time.sleep(2)         else:           self.data.put(val_odd)           time.sleep(2)       except:         print "%s: %s finished!" % (time.ctime(), self.getName())         break #Main thread def main():   queue = Queue()   producer = Producer('Pro.', queue)   consumer_even = Consumer_even('Con_even.', queue)   consumer_odd = Consumer_odd('Con_odd.',queue)   producer.start()   consumer_even.start()   consumer_odd.start()   producer.join()   consumer_even.join()   consumer_odd.join()   print 'All threads terminate!'    if __name__ == '__main__':   main()

 

如果main函数写成上面的样本，本来我想要的是将会得到一个队列，将其作为参数传入进程池子里的每个子进程，但是却得到

RuntimeError: Queue objects should only be shared between processes through inheritance

的错误，查了下，大意是队列对象不能在父进程与子进程间通信，这个如果想要使用进程池中使用队列则要使用multiprocess的Manager类

if __name__=='__main__':
    manager = multiprocessing.Manager()
    # 父进程创建Queue，并传给各个子进程：
    q = manager.Queue()
    p = Pool()
    pw = p.apply_async(write,args=(q,))
    time.sleep(0.5)
    pr = p.apply_async(read,args=(q,))
    p.close()
    p.join()
    
    print
    print '所有数据都写入并且读完'

这样这个队列对象就可以在父进程与子进程间通信，不用池则不需要Manager，以后再扩展multiprocess中的Manager类吧

关于锁的应用，在不同程序间如果有同时对同一个队列操作的时候，为了避免错误，可以在某个函数操作队列的时候给它加把锁，这样在同一个时间内则只能有一个子进程对队列进行操作，锁也要在manager对象中的锁

#coding:gbk

from multiprocessing import Process,Queue,Pool
import multiprocessing
import os, time, random

# 写数据进程执行的代码:
def write(q,lock):
    lock.acquire() #加上锁
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)       
        q.put(value)        
    lock.release() #释放锁  

# 读数据进程执行的代码:
def read(q):
    while True:
        if not q.empty():
            value = q.get(False)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break

if __name__=='__main__':
    manager = multiprocessing.Manager()
    # 父进程创建Queue，并传给各个子进程：
    q = manager.Queue()
    lock = manager.Lock() #初始化一把锁
    p = Pool()
    pw = p.apply_async(write,args=(q,lock))    
    pr = p.apply_async(read,args=(q,))
    p.close()
    p.join()
    
    print
    print '所有数据都写入并且读完'