python函数任务队列

1. python实现简单多线程任务队列

Python实现简单多线程任务队列
最近我在用梯度下降算法绘制神经网络的数据时，遇到了一些算法性能的问题。梯度下降算法的代码如下（伪代码）：
defgradient_descent(): # the gradient descent code plotly.write(X, Y)
一般来说，当网络请求 plot.ly 绘图时会阻塞等待返回，于是也会影响到其他的梯度下降函数的执行速度。
一种解决办法是每调用一次 plotly.write 函数就开启一个新的线程，但是这种方法感觉不是很好。 我不想用一个像 cerely（一种分布式任务队列）一样大而全的任务队列框架，因为框架对于我的这点需求来说太重了，并且我的绘图也并不需要 redis 来持久化数据。
那用什么办法解决呢？我在 python 中写了一个很小的任务队列，它可以在一个单独的线程中调用 plotly.write函数。下面是程序代码。
classTaskQueue(Queue.Queue):
首先我们继承 Queue.Queue 类。从 Queue.Queue 类可以继承 get 和 put 方法，以及队列的行为。
def__init__(self, num_workers=1): Queue.Queue.__init__(self) self.num_workers=num_workers self.start_workers()
初始化的时候，我们可以不用考虑工作线程的数量。
defadd_task(self, task,*args,**kwargs): args=argsor() kwargs=kwargsor{} self.put((task, args, kwargs))
我们把 task, args, kwargs 以元组的形式存储在队列中。*args 可以传递数量不等的参数，**kwargs 可以传递命名参数。
defstart_workers(self): foriinrange(self.num_workers): t=Thread(target=self.worker) t.daemon=True t.start()
我们为每个 worker 创建一个线程，然后在后台删除。
下面是 worker 函数的代码：
defworker(self): whileTrue: tupl=self.get() item, args, kwargs=self.get() item(*args,**kwargs) self.task_done()
worker 函数获取队列顶端的任务，并根据输入参数运行，除此之外，没有其他的功能。下面是队列的代码：
我们可以通过下面的代码测试：
defblokkah(*args,**kwargs): time.sleep(5) print“Blokkah mofo!” q=TaskQueue(num_workers=5) foriteminrange(1): q.add_task(blokkah) q.join()# wait for all the tasks to finish. print“Alldone!”
Blokkah 是我们要做的任务名称。队列已经缓存在内存中，并且没有执行很多任务。下面的步骤是把主队列当做单独的进程来运行，这样主程序退出以及执行数据库持久化时，队列任务不会停止运行。但是这个例子很好地展示了如何从一个很简单的小任务写成像工作队列这样复杂的程序。
defgradient_descent(): # the gradient descent code queue.add_task(plotly.write, x=X, y=Y)
修改之后，我的梯度下降算法工作效率似乎更高了。如果你很感兴趣的话，可以参考下面的代码。 classTaskQueue(Queue.Queue): def__init__(self, num_workers=1):Queue.Queue.__init__(self)self.num_workers=num_workersself.start_workers() defadd_task(self, task,*args,**kwargs):args=argsor()kwargs=kwargsor{}self.put((task, args, kwargs)) defstart_workers(self):foriinrange(self.num_workers):t=Thread(target=self.worker)t.daemon=Truet.start() defworker(self):whileTrue:tupl=self.get()item, args, kwargs=self.get()item(*args,**kwargs)self.task_done() deftests():defblokkah(*args,**kwargs):time.sleep(5)print"Blokkah mofo!" q=TaskQueue(num_workers=5) foriteminrange(10):q.add_task(blokkah) q.join()# block until all tasks are doneprint"All done!" if__name__=="__main__":tests()

2. Python 队列queue与多线程组合（生产者+消费者模式）

在线程世界⾥，⽣产者就是⽣产数据的线程，消费者就是消费数据的线程。在多线程开发当中，如果⽣产者处理速度很快，⽽消费者处理速度很慢，那么⽣产者就必须等待消费者处理完，才能继续⽣产数据。同样的道理，如果消费者的处理能⼒⼤于⽣产者，那么消费者就必须等待⽣产者。为了解决这个问题于是引⼊了⽣产者和消费者模式。

⽣产者消费者模式是通过⼀个容器来解决⽣产者和消费者的强耦合问题。⽣产者和消费者彼此之间不直接通讯，⽽通过阻塞队列来进⾏通讯，所以⽣产者⽣产完数据之后不⽤等待消费者处理，直接扔给阻塞队列，消费者不找⽣产者要数据，⽽是唯租直接从阻塞队列⾥取，阻塞队列就相当于⼀个缓冲区，平衡了⽣产者和消费者的处理能⼒。

比如，对于同时爬取多个网页的多线程爬虫，在某一时刻你可能无法保证他们在处理不同的网站，在某些时刻他们极有可能在处理相同的网站，这岂不浪费？为了解决这个问题，可以将不同网页的url放在queue中，然后多个线程来读取queue中的url进行解析处理，而queue只允许一次出一个，出一个少一个。相同网站上不同网页的url通常有某种规律，比如某个字段的数字加1，这种情况完全可以用这种模式，“生产者程序”负责根据规律把完整的url制作出来，再塞进queue里面（如果queue满了，则等待）；“消费者程序（网页解析程序）”从queue的后面答团挨个取出url进行解析（如果queue里面是空的，则等待），即使是多线程也能保证每个线程得到的是不同的url。这个过程中，生产者和消费彼此互不干涉。

下面以实例说明如何将queue与多线程相结合形成所谓的“ 生产者+消费者 ”模式，同时解决 多线程如何退出 的问题（注意下例中是“一个生产者+多个消费者”的形式，多生产者+多消费者的模式可在此基础上进一步实现）：

上述程序的过程如下图：

注意 ：
（1）上述程序中生产者插入queue的时间间隔为0.1s，而消费者的取出时间间隔为2s，显然消费速度不如生产速度，一开始queue是空的，一段时间后queue就变满了，输出结果正说明了这一点。如果将两个时间调换，则结果相反，queue永远不会满，甚至只有1个值，因为只要进去就被消费了。
（2）消费者程序是通过“while”来推动不断执行的，何时结束？上例中通过在queue中增加None的形式告诉消费者，生产者已经结束了，消费者也可以结束了。但消费者有多个，到底由哪个消费者得到None？为解决这个问题，上例中在消费者中先判断当前取出的是不是None，如果是，则先在queue里插入一个None，然后再break当前这个消费者线程，最后的结果是所有的消费者线程都退出了，但queue中还剩下None没有被取出。因此在程序的后面增加了一个for循环来挨个把queue中的元素取出，否则最后的q.join()将永远阻塞，程序无法往下执行。
（3）程序中每一个q.get()后面都跟有一个q.task_done()，其作用指举兆是从queue中取出一个元素就给q.join()发送一个信息，否则q.join()将永远处于阻塞状态，直到所有queue元素都被取出。

多线程“生产者-消费者”模式一般性结构图

3. python多进程中队列不空时阻塞，求解为什么

最近接触一个项目，要在多个虚拟机中运行任务，参考别人之前项目的代码，采用了多进程来处理，于是上网查了查python中的多进程

一、先说说Queue（队列对象）

Queue是python中的标准库，可以直接import 引用，之前学习的时候有听过着名的“先吃先拉”与“后吃先吐”，其实就是这里说的队列，队列的构造的时候可以定义它的容量，别吃撑了，吃多了，就会报错,构造的时候不写或者写个小于1的数则表示无限多

import Queue

q = Queue.Queue(10)

向队列中放值(put)

q.put(‘yang')

q.put(4)

q.put([‘yan','xing'])

在队列中取值get()

默认的队列是先进先出的

>>> q.get()
‘yang'
>>> q.get()
4
>>> q.get()
[‘yan', ‘xing']

当一个队列为空的时候如果再用get取则会堵塞，所以取队列的时候一般是用到

get_nowait()方法，这种方法在向一个空队列取值的时候会抛一个Empty异常

所以更常用的方法是先判断一个队列是否为空，如果不为空则取值

队列中常用的方法

Queue.qsize() 返回队列的大小
Queue.empty() 如果队列为空，返回True,反之False
Queue.full() 如果队列满了，返回True,反之False
Queue.get([block[, timeout]]) 获取队列，timeout等待时间
Queue.get_nowait() 相当Queue.get(False)
非阻塞 Queue.put(item) 写入队列，timeout等待时间
Queue.put_nowait(item) 相当Queue.put(item, False)

二、multiprocessing中使用子进程概念

from multiprocessing import Process

可以通过Process来构造一个子进程

p = Process(target=fun,args=(args))

再通过p.start()来启动子进程

再通过p.join()方法来使得子进程运行结束后再执行父进程

from multiprocessing import Process
import os

# 子进程要执行的代码
def run_proc(name):
print 'Run child process %s (%s)...' % (name, os.getpid())

if __name__=='__main__':
print 'Parent process %s.' % os.getpid()
p = Process(target=run_proc, args=('test',))
print 'Process will start.'
p.start()
p.join()
print 'Process end.'

上面的程序运行后的结果其实是按照上图中1，2，3分开进行的，先打印1，3秒后打印2，再3秒后打印3

代码中的p.close()是关掉进程池子，是不再向里面添加进程了，对Pool对象调用join()方法会等待所有子进程执行完毕，调用join()之前必须先调用close()，调用close()之后就不能继续添加新的Process了。

当时也可以是实例pool的时候给它定义一个进程的多少

如果上面的代码中p=Pool(5)那么所有的子进程就可以同时进行

三、多个子进程间的通信

多个子进程间的通信就要采用第一步中说到的Queue，比如有以下的需求，一个子进程向队列中写数据，另外一个进程从队列中取数据，

#coding:gbk

from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
for value in ['A', 'B', 'C']:
print 'Put %s to queue...' % value
q.put(value)
time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
while True:
if not q.empty():
value = q.get(True)
print 'Get %s from queue.' % value
time.sleep(random.random())
else:
break

if __name__=='__main__':
# 父进程创建Queue，并传给各个子进程：
q = Queue()
pw = Process(target=write, args=(q,))
pr = Process(target=read, args=(q,))
# 启动子进程pw，写入:
pw.start()
# 等待pw结束:
pw.join()
# 启动子进程pr，读取:
pr.start()
pr.join()
# pr进程里是死循环，无法等待其结束，只能强行终止:
print
print '所有数据都写入并且读完'

四、关于上面代码的几个有趣的问题

if __name__=='__main__':
# 父进程创建Queue，并传给各个子进程：
q = Queue()
p = Pool()
pw = p.apply_async(write,args=(q,))
pr = p.apply_async(read,args=(q,))
p.close()
p.join()

print
print '所有数据都写入并且读完'

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

4. Python 异步任务队列Celery 使用

在 Python 中定义 Celery 的时候，我们要引入 Broker，中文翻译过来就是“中间人”的意思。在工头(生产者)提出任务的时候，把所有的任务放到 Broker 里面，在 Broker 的另外一头，一群码农(消费者)等着取出一个个任务准备着手做。这种模式注定了整个系统会是个开环系统，工头对于码农们把任务做的怎样是不知情的。所以我们要引入 Backend 来保存每次任务的结果。这个 Backend 也是存储任务的信息用的，只不过这里存的是那些任务的返回结果。我们可以选择只让错误执行的任务返回结果到 Backend，这样我们取回结果，便可以知道有多少任务执行失败了。

其实现架构如下图所示：

可以看到，Celery 主要包含以下几个模块：

celery可以通过pip自动安装。

broker 可选择使用RabbitMQ/redis，backend可选择使用RabbitMQ/redis/MongoDB。RabbitMQ/redis/mongoDB的安装请参考对应的官方文档。

------------------------------rabbitmq相关----------------------------------------------------------

官网安装方法： http://www.rabbitmq.com/install-windows.html

启动管理插件：sbin/rabbitmq-plugins enable rabbitmq_management 启动rabbitmq：sbin/rabbitmq-server -detached

rabbitmq已经启动，可以打开页面来看看 地址： http://localhost:15672/#/

用户名密码都是guest 。进入可以看到具体页面。 关于rabbitmq的配置，网上很多 自己去搜以下就ok了。

------------------------------rabbitmq相关--------------------------------------------------------

项目结构如下：

使用前，需要三个方面：celery配置，celery实例，需执行的任务函数，如下：

Celery 的配置比较多，可以在 官方配置文档： http://docs.celeryproject.org/en/latest/userguide/configuration.html 查询每个配置项的含义。

当然，要保证上述异步任务and下述定时任务都能正常执行，就需要先启动celery worker，启动命令行如下:

需 启动beat ，执行定时任务时, Celery会通过celery beat进程来完成。Celery beat会保持运行, 一旦到了某一定时任务需要执行时, Celery beat便将其加入到queue中. 不像worker进程, Celery beat只需要一个即可。而且为了避免有重复的任务被发送出去，所以Celery beat仅能有一个。

命令行启动：

如果你想将celery worker/beat要放到后台运行，推荐可以扔给supervisor。

supervisor.conf如下：

5. 璋堣皥python閲岄溃鍏充簬浠诲姟阒熷垪

瑕佸洖绛旇繖涓闂棰樻垜浠棣栧厛鐪嬬湅鍦ㄦ祦姘寸嚎涓婄殑妗埚垪锛屽傛灉浜虹殑阃熷害寰堟参锛屾満鍣ㄧ殑阃熷害姣斾汉镄勯熷害蹇寰埚氾纴灏变细阃犳垚锛屾満鍣ㄧ敓浜х殑涓滆タ娌℃湁鍙婃椂澶勭悊锛岃秺绉瓒婂氾纴阃犳垚阒诲烇纴褰卞搷鐢熶骇銆

镓扑釜姣旀柟濡傛灉鍑虹幇浜虹殑阃熷害璺熶笉涓婃満鍣ㄩ熷害镐庝箞锷烇纴杩欎釜镞跺欐垜浠灏遍渶瑕佺涓夋柟锛岀洃绠′汉锻桡纸浠诲姟阒熷垪锛夋妸链哄櫒鐢熶骇镄勪笢瑗匡纴鏀惧湪涓涓鍦版柟锛岋纸阒熷垪锛夛纴铹跺悗鍒嗛厤缁欐疮涓鐢ㄦ埛锛屾湁𨱒′笉鐞嗙殑镓ц屻

娑堟伅阒熷垪
娑堟伅阒熷垪镄勮緭鍏ユ槸宸ヤ綔镄勪竴涓鍗曞厓锛岀О涓轰换锷★纴镫绔嬬殑镵岀▼锛圵orker锛夎繘绋嬫寔缁鐩戣嗛槦鍒椾腑鏄钖︽湁闇瑕佸勭悊镄勬柊浠诲姟銆
Celery 鐢ㄦ秷鎭阃氢俊锛岄氩父浣跨敤涓闂翠汉锛圔roker锛夊湪瀹㈡埛绔鍜岃亴绋嬮棿鏂℃棆銆傝繖涓杩囩▼浠庡㈡埛绔钖戦槦鍒楁坊锷犳秷鎭寮濮嬶纴涔嫔悗涓闂翠汉鎶婃秷鎭娲鹃佺粰镵岀▼锛岃亴绋嫔规秷鎭杩涜屽勭悊銆傚备笅锲炬墍绀猴细

鐜澧

浠诲姟鑴氭湰

flower github

鍦234 涓奻lower.py 镄勮剼链

6. python实现堆栈与队列的方法

python实现堆栈与队列的方法
本文实例讲述了python实现堆栈与队列的方法。分享给大家供大家参考。具体分析如下：
1、python实现堆栈，可先将Stack类写入文件stack.py，在其它程序文件中使用from stack import Stack，然后就可以使用堆栈了。
stack.py的程序:
代码如下:class Stack():
def __init__(self,size):
self.size=size;
self.stack=[];
self.top=-1;
def push(self,ele): #入栈之前检查栈是否已满
if self.isfull():
raise exception("out of range");
else:
self.stack.append(ele);
self.top=self.top+1;
def pop(self): # 出栈之前检查栈是否为空
if self.isempty():
raise exception("stack is empty");
else:
self.top=self.top-1;
return self.stack.pop();

def isfull(self):
return self.top+1==self.size;
def isempty(self):
return self.top==-1;
再写一个程序文件，stacktest.py,使用栈，内容如下:
代码如下:#!/usr/bin/python
from stack import Stack
s=Stack(20);
for i in range(3):
s.push(i);
s.pop()
print s.isempty();

2、python 实现队列:
复制代码代码如下:class Queue():
def __init__(self,size):
self.size=size;
self.front=-1;
self.rear=-1;
self.queue=[];
def enqueue(self,ele): #入队操作
if self.isfull():
raise exception("queue is full");
else:
self.queue.append(ele);
self.rear=self.rear+1;
def dequeue(self): #出队操作
if self.isempty():
raise exception("queue is empty");
else:
self.front=self.front+1;
return self.queue[self.front];
def isfull(self):
return self.rear-self.front+1==self.size;
def isempty(self):
return self.front==self.rear;

q=Queue(10);
for i in range(3):
q.enqueue(i);
print q.dequeue();
print q.isempty();
希望本文所述对大家的Python程序设计有所帮助。

7. python生成多个队列

q=[]
foriinrange(9):
q.append(Queue())