python队列queue

1. queue——同步的队列类

   queue模块实现了多生产者，多消费者的队列。当 要求信息必须在多线程间安全交换，这个模块在 线程编程时非常有用 。Queue模块实现了所有要求的锁机制。  说了半天就是Queue模块主要是多线程，保证线程安全使用的。

2.Python 中Queue模块有三种队列及构造函数:　　

1. class queue.Queue(maxsize = 0)

　构造一个FIFO队列，maxsize可以限制队列的大小。如果队列的大小达到了队列的上限，就会加锁，加入就会阻塞，直到队列的内容被消费掉。maxsize的值小于等于0，那么队列的尺寸就是无限制的

　2. class queue.LifoQueue(maxsize = 0)

　构造一个Lifo队列

　3. class PriorityQueue(maxsize = 0)

　优先级最低的先出去，优先级最低的一般使用sorted(list(entries))[0])。典型加入的元素是一个元祖(优先级, 数据）

put(item, block=True, timeout=None): 往队列里放数据。如果满了的话，block = False 直接报 Full异常。如果block = True，就是等一会，timeout必须为 0 或正数。None为一直等下去，0为不等，正数n为等待n秒还不能存入，报Full异常

get(item, block=True, timeout=None): 从队列里取数据。如果为空的话，block = False 直接报 empty异常。如果block = True，就是等一会，timeout必须为 0 或正数。None为一直等下去，0为不等，正数n为等待n秒还不能读取，报empty异常。

执行结果为：

empty() 如果队列为空，返回True,反之False

执行结果为：

full() 如果队列满了，返回True,反之False

full 与 maxsize 大小对应

执行结果为：

get([block[, timeout]]) 获取队列，timeout等待时间

执行结果为：

3秒内获取数据，没有就报异常

get_nowait() 相当q.get(False) 非阻塞 q.put(item) 写入队列，timeout等待时间

put_nowait(item) 相当q.put(item, False)

q.task_done() 在完成一项工作之后，q.task_done() 函数向任务已经完成的队列发送一个信号

q.join() 实际上意味着等到队列为空，再执行别的操作

与多线程一起操作

import random, threading, time
from Queue import Queue


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):
            num = random.randint(1, 10)
            print "%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), num)
            self.data.put(num)
            time.sleep(1)
        print "%s: %s finished!" % (time.ctime(), self.getName())


class Consumer(threading.Thread):
    def __init__(self, name, queue):
        super(Consumer, self).__init__(name=name)
        self.data = queue

    def run(self):
        while 1:
            try:
                val_even = self.data.get(1, 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(0.2)
                else:
                    self.data.put(val_even)
                    time.sleep(0.2)
            except:
                print "%s: %s finished!" % (time.ctime(), self.getName())
                break


class ConsumerOther(threading.Thread):
    def __init__(self, name, queue):
        super(ConsumerOther, self).__init__(name=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(0.2)
                else:
                    self.data.put(val_odd)
                    time.sleep(0.2)
            except:
                print "%s: %s finished!" % (time.ctime(), self.getName())
                break


def main():
    queue = Queue()
    producer = Producer('Pro', queue)
    consumer = Consumer('Con', queue)
    consumerOther = ConsumerOther('Conother', queue)
    producer.start()
    consumer.start()
    consumerOther.start()
    producer.join()
    consumer.join()
    consumerOther.join()
    print 'All threads terminate!'


if __name__ == '__main__':
    main()

执行结果为：

这个就是一个生产者和消费者的例子：

1.Producer我们随机将1到10之间数字放进去队列；

2.Consumer获取队列的一个数值，如果为双数，打印出来，如果为单数，放回去队列；

3.ConsumerOther获取队列的一个数值，如果为双数，放回队列，如果为单数，打印出来；

4.3个线程同时进行，首先是生产结束，打印信息

然后是消费者相继结束，打印信息

当所有结束时候打印队列完成信息

如果生产不结束的话，这个程序就会一直执行下去。