queue模块

queue模块

线程间以队列的形式进行通信，Queue 是提供队列操作的模块，有三种队列：FIFO（先进先出）、LIFO（后进先出）、Priority（根据优先级来进出）

q = Queue.Queue() ：用于定义队列的最大长度，如 Queue.Queue(5) 表示队列的最大长度为 5（意思即只能存5个数据），如果不加任何参数则不限长度

q.empty() ：用于查看队列是否为空，如果队列为空则返回 True ，不为空返回 False

q.full() ：用于查看队列是否满了（满了就不能往队列里添加数据了），如果满了则返回 True ，不满返回 False
q.maxsize ：用于查看队列支持的最大长度，注意这是一个属性，不是一个方法，后面没有加括号
q.put() ：用于往队列里添加数据，如 q.put('abc') 表示添加一个字符串 abc 数据，如果队列满了则新添加的数据会被阻塞
q.get() ：用于从队列里获取数据，如果是先进先出的队列，则先进的数据会被先取出来，每次只取一个数据
q.queue.clear() ：用于清空队列

实现不断地从队列里存数据和取数据：

#!/usr/bin/env python

import time
import Queue
import random
import threading

class consumer(threading.Thread):
    def __init__(self, queue):
        threading.Thread.__init__(self)
        self.queue = queue

    def run(self):
        while True:
            if self.queue.empty():
                break
            data = self.queue.get()
            print self.name, data
            time.sleep(1)

if __name__ == '__main__':
    queue = Queue.Queue(10)
    for i in xrange(10):
        queue.put(random.randint(1, 9))    # 不断地从队列中存数据，且规定队列长度为10
    for i in xrange(3):
        c = consumer(queue)                # 不断地从队列中取数据，且以线程的方式
        c.start()

使用三个线程，实现一个线程不断生成一个随机数到一个队列中，一个线程从队列中不断地取出奇数，一个线程从队列中不断地取出偶数

#!/usr/bin/env python

import threading
import random
import Queue
import time

def producer(name, queue):
    for i in xrange(10):
        num = random.randint(1,10)
        th_name = name + '-' + threading.currentThread().getName()
        print "%s: %s ---> %s" % (time.ctime(), th_name, num)
        queue.put(num)
        time.sleep(1)

def odd(name, queue):
    th_name = name + '-' + threading.currentThread().getName()
    while True:
        try:
            val_odd = queue.get(1,5)
            if val_odd % 2 != 0:
                print "%s: %s ---> %s" % (time.ctime(), th_name, val_odd)
                time.sleep(1)
            else:
                queue.put(val_odd)
                time.sleep(1)
        except:
            print "%s: %s finished" % (time.ctime(), th_name)
            break

def even(name, queue):
    th_name = name + '-' + threading.currentThread().getName()
    while True:
        try:
            val_even = queue.get(1,5)
            if val_even % 2 == 0:
                print "%s: %s ---> %s" % (time.ctime(), th_name, val_even)
                time.sleep(1)
            else:
                queue.put(val_even)
                time.sleep(1)
        except:
            print "%s: %s finished" % (time.ctime(), th_name)
            break

def main():
    q = Queue.Queue(10)
    t_pro = threading.Thread(target=producer, args=('pro',q))
    t_odd = threading.Thread(target=odd, args=('odd',q))
    t_even = threading.Thread(target=even, args=('even',q))
    t_pro.start()
    t_odd.start()
    t_even.start()

if __name__ == '__main__':
    main()