python利用队列（queue）实现多线程同步（生产者-消费者模型）

python队列Queue

Queue队列是线程安全的，实现了所有需要的锁原语，所以使用Queue进行多线程同步就可以不用考虑资源锁的问题。

Queue实现了三种类型的队列

1. FIFO队列（先进先出），第一个加入队列的对象被第一个取出，举个例子：

from queue import Queue

q=Queue(maxsize=0)#构造一个FIFO队列,maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据. 当maxsize小于或者等于0, 表示不限制队列的大小(默认)
for i in range(5):
   	q.put(i)
while not q.empty():
   	print(q.get())

输出：
0
1
2
3
4

2. LIFO队列（后进先出），最后加入队列的对象被第一个取出，类似栈，总是从栈顶取出，举个例子：

from queue import Queue,LifoQueue,PriorityQueue

q=LifoQueue(maxsize=0)#构造一个LIFO队列,maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据. 当maxsize小于或者等于0, 表示不限制队列的大小(默认)
for i in range(5):
    q.put(i)
while not q.empty():
    print(q.get()

输出：
4
3
2
1
0

3. PriorityQueue队列（优先级），保持队列数据有序，最小值被先取出（可以重写数据类型和排序规则的，这里不深究），举个例子：

from queue import Queue,LifoQueue,PriorityQueue

q=PriorityQueue(maxsize=0)#构造一个优先级队列,maxsize设置队列大小的上界, 如果插入数据时, 达到上界会发生阻塞, 直到队列可以放入数据. 当maxsize小于或者等于0, 表示不限制队列的大小(默认)
q.put(8)
q.put(6)
q.put(1)
q.put(5)
while not q.empty():
    print(q.get())

输出：
1
5
6
8

三种队列对象提供的公共方法

Queue.empty()  #如果队列为空, 返回True(注意队列为空时, 并不能保证调用put()不会阻塞); 队列不空返回False(不空时, 不能保证调用get()不会阻塞)
Queue.full()  #如果队列为满, 返回True(不能保证调用get()不会阻塞), 如果队列不满, 返回False(并不能保证调用put()不会阻塞)
 
Queue.put(item[, block[, timeout]])  #向队列中放入元素, 如果可选参数block为True并且timeout参数为None(默认), 为阻塞型put(). 如果timeout是正数, 会阻塞timeout时间并引发Queue.Full异常. 如果block为False为非阻塞put
Queue.put_nowait(item)  #等价于put(itme, False)
 
Queue.get([block[, timeout]])  #移除列队元素并将元素返回, block = True为阻塞函数, block = False为非阻塞函数. 可能返回Queue.Empty异常
Queue.get_nowait()  #等价于get(False)
 
Queue.task_done()  #在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
Queue.join()  #实际上意味着等到队列为空，再执行别的操作

官方文档给出的多线程模型

def worker():
    while True:
        item = q.get()
        do_work(item)
        q.task_done()
 
q = Queue()
for i in range(num_worker_threads):
     t = Thread(target=worker)
     t.daemon = True
     t.start()
 
for item in source():
    q.put(item)
 
q.join()       # block until all tasks are done

线程同步：生产者-消费者模型

from queue import Queue

import random

import threading

import time

# 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(5):
            print("%s: %s is producing %d to the queue!" % (time.ctime(), self.getName(), i))

            self.data.put(i)

            time.sleep(random.randrange(10) / 5)

        print("%s: %s finished!" % (time.ctime(), self.getName()))


# Consumer thread

class Consumer(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(5):
            val = self.data.get()

            print("%s: %s is consuming. %d in the queue is consumed!" % (time.ctime(), self.getName(), val))

            time.sleep(random.randrange(10))

        print("%s: %s finished!" % (time.ctime(), self.getName()))


# Main thread

def main():
    queue = Queue()

    producer = Producer('Pro.', queue)

    consumer = Consumer('Con.', queue)

    producer.start()

    consumer.start()

    producer.join()

    consumer.join()
    print('All threads terminate!')


if __name__ == '__main__':
    main()

运行结果：
Mon Jul 29 11:52:57 2019: Pro. is producing 0 to the queue!
Mon Jul 29 11:52:57 2019: Con. is consuming. 0 in the queue is consumed!
Mon Jul 29 11:52:58 2019: Pro. is producing 1 to the queue!
Mon Jul 29 11:52:59 2019: Pro. is producing 2 to the queue!
Mon Jul 29 11:52:59 2019: Pro. is producing 3 to the queue!
Mon Jul 29 11:52:59 2019: Pro. is producing 4 to the queue!
Mon Jul 29 11:53:01 2019: Pro. finished!
Mon Jul 29 11:53:04 2019: Con. is consuming. 1 in the queue is consumed!
Mon Jul 29 11:53:10 2019: Con. is consuming. 2 in the queue is consumed!
Mon Jul 29 11:53:19 2019: Con. is consuming. 3 in the queue is consumed!
Mon Jul 29 11:53:25 2019: Con. is consuming. 4 in the queue is consumed!
Mon Jul 29 11:53:31 2019: Con. finished!
All threads terminate!