队列：
队列可以并发的派多个线程，对排列的线程处理，并切每个需要处理线程只需要将请求的数据放入队列容器的内存中，线程不需要等待，当排列完毕处理完数据后，线程在准时来取数据即可。请求数据的线程只与这个队列容器存在关系，处理数据的线程down掉不会影响到请求数据的线程，队列会派给其他线程处理这分数据，它实现了解耦，提高效率。队列内会有一个有顺序的容器，列表与这个容器是有区别的，列表中数据虽然是排列的，但数据被取走后还会保留，而队列中这个容器的数据被取后将不会保留。当必须在多个线程之间安全地交换信息时，队列在线程编程中特别有用。
Python四种类型的队例：
Queue：FIFO 即first in first out 先进先出LifoQueue：LIFO 即last in first out 后进先出PriorityQueue：优先队列，级别越低，越优先
deque:双边队列Queue 先进先出队列：
#基本FIFO队列 先进先出 FIFO即First in First Out,先进先出
#maxsize设置队列中，数据上限，小于或等于0则不限制，容器中大于这个数则阻塞，直到队列中的数据被消掉
q = Queue(maxsize=0)
#写入队列数据
q.put(0)
q.put(1)
q.put(2)
#输出当前队列所有数据
print(q.queue)
#删除队列数据，并返回该数据
q.get()
#输也所有队列数据
print(q.queue)
# 输出:
# deque([0, 1, 2])
# deque([1, 2])生产消费模型：
#生产消费模型
qq = Queue(maxsize=10)
def product(name):
count = 1
while True:
q.put('步枪{}'.format(count))
print('{}生产步枪{}支'.format(name,count))
count+=1
time.sleep(0.3)
def cousume(name):
while True:
print('{}装备了{}'.format(name,q.get()))
time.sleep(0.3)
q.task_done()
#部队线程
p = threading.Thread(target=product,args=('张三',))
k = threading.Thread(target=cousume,args=('李四',))
w = threading.Thread(target=cousume,args=('王五',))
p.start()
k.start()
w.start()
Python多线程与Queue队列多线程在感官上类似于同时执行多个程序，虽然由于GIL的存在，在Python中无法实现线程的真正并行，但是对于某些场景，多线程仍不失为一个有效的处理方法：
1，不紧急的，无需阻塞主线程的任务，此时可以利用多线程在后台慢慢处理；
2，IO密集型操作，比如文件读写、用户输入和网络请求等，此时多线程可以近似达到甚至优于多进程的表现；
多线程的基本使用不再赘述，以下语法便可轻松实现：
def task(args1, args2):
pass
Thread(
target=task,
args=(args1, args2)
).start()这里我们重点关注线程通信。
假设有这么一种场景：有一批源数据，指定一个操作系数N，需要分别对其进行与N的加减乘除操作，并将结果汇总。
当然这里的加减乘除只是一种简单处理，在实际的生产环境中，它其实代表了一步较为复杂的业务操作，并包含了较多的IO处理。
自然我们想到可以开启多线程处理，那么紧接着的问题便是：如何划分线程，是根据处理步骤划分，还是根据源数据划分？
对于前者，我们把涉及的业务操作单独划分位一个线程，即有4个线程分别进行加减乘除的操作，显然上一个线程的结果是下一个线程的输入，这类似于流水线操作；
而后者则是把源数据分为若干份，每份启动一个线程进行处理，最终把结果汇总。一般来说，我们推荐第一种方式。因为在一个线程中完成所有的操作不如每步一个线程清晰明了，
尤其是在一些复杂的场景下，会加大单个线程的出错概率和测试难度。
那么我们将开辟4个线程，分别执行加减乘除操作。最后一个除法线程结束则任务完成
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from Queue import Queue
from threading import Thread
class NumberHandler(object):
def __init__(self, n):
self.n = n
def add(self, num):
return num + self.n
def subtract(self, num):
return num - self.n
def multiply(self, num):
return num * self.n * self.n
def divide(self, num):
return num / self.n
class ClosableQueue(Queue):
SENTINEL = object()
def close(self):
self.put(self.SENTINEL)
def __iter__(self):
while True:
item = self.get()
try:
if item is self.SENTINEL:
return
yield item
finally:
self.task_done()
class StoppableWorker(Thread):
def __init__(self, func, in_queue, out_queue):
super(StoppableWorker, self).__init__()
self.in_queue = in_queue
self.out_queue = out_queue
self.func = func
def run(self):
for item in self.in_queue:
result = self.func(item)
self.out_queue.put(result)
print self.func
if __name__ == '__main__':
source_queue = ClosableQueue()
add_queue = ClosableQueue()
subtract_queue = ClosableQueue()
multiply_queue = ClosableQueue()
divide_queue = ClosableQueue()
result_queue = ClosableQueue()
number_handler = NumberHandler(5)
threads = [
StoppableWorker(number_handler.add, add_queue, subtract_queue),
StoppableWorker(number_handler.subtract, subtract_queue, multiply_queue),
StoppableWorker(number_handler.multiply, multiply_queue, divide_queue),
StoppableWorker(number_handler.divide, divide_queue, result_queue),
]
for _thread in threads:
_thread.start()
for i in range(10):
add_queue.put(i)
add_queue.close()
add_queue.join()
print 'add job done...'
subtract_queue.close()
subtract_queue.join()
print 'subtract job done...'
multiply_queue.close()
multiply_queue.join()
print 'multiply job done...'
divide_queue.close()
divide_queue.join()
print 'divide job done...'
result_queue.close()
print "%s items finished, result: %s" % (result_queue.qsize(), result_queue)
for i in result_queue:
print i
