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 '所有数据都写入并且读完'