celery 原理理解

这里有一篇写的不错的：http://www.jianshu.com/p/1840035cb510

自己的“格式化”后的内容备忘下：

　　我们总在说c10k的问题， 也做了不少优化， 然后优化总是不够的。

　　其中的一个瓶颈就是一些耗时的操作（网络请求/文件操作--含耗时的数据库操作）。

　　如果我们不关心他们的返回值，则可以将其做成异步任务，保证执行成功即可。

　　

　　开始阐述之前约定一些概念：

　　　　1. web请求处理进程（简称：消息生产者，记做P）， 这是我们c10k问题注意的焦点

　　　　2. 消息的处理者（简称：消费者，记做C)， 在成功“男人”后面默默无闻工作的“女人”　　

　　　　3. 消息存放的地方（简称： 消息队列， 记做Q）

　　　　4. 消息/任务， 记做T

基本处理过程：

　　　　1. P将T保存到Q

　　　　2. C从Q中取出一个T实例， 处理， 若处理失败则将T示例退回到Q（务必保证T得到成功处理）。

　　

　　最简单的实现方案：

　　　　redis 消息队列（利用redis list类型）的lpush/rpop(brpop)来处理。python代码如下：

　　　　TaskServer.py

# -*- coding:utf-8 -*-
import traceback
import simplejson
import redis
import uuid
from functools import wraps
 
class TaskExecutor(object):
	def __init__(self, task_name ,  *args, **kwargs):
		self.queue =  redis.StrictRedis()#host='localhost', port=6378, db=0, password='xxx_tasks')
		self.task_name = task_name
 
	def _publish_task(self, task_id , func, *args, **kwargs):
		self.queue.lpush(self.task_name,
			simplejson.dumps({'id':task_id, 'func':func, 'args':args, 'kwargs':kwargs})
		)
 
	def task(self, func):#decorator
		setattr(func,'delay',lambda *args, **kwargs:self._publish_task(uuid.uuid4().hex, func.__name__, *args, **kwargs))
		@wraps(func)
		def _w(*args, **kwargs):
			return func(*args, **kwargs)
		return _w
 
	def run(self):
		print 'waiting for tasks...'
		while True:
			if self.queue.llen(self.task_name):
				msg_data = simplejson.loads( self.queue.rpop(self.task_name))#这里可以用StrictRedis实例的brpop改善，去掉llen轮询。
 
				print 'handling task(id:{0})...'.format(msg_data['id'])
				try:
					if msg_data.get('func',None):
						func = eval(msg_data.get('func'))
						if callable(func):
							#print msg_data['args'], msg_data['kwargs']
							ret = func(*msg_data['args'], **msg_data['kwargs'])
							msg_data.update({'result':ret})
							self.queue.lpush(self.task_name+'.response.success', simplejson.dumps(msg_data) )
				except:
					msg_data.update({'failed_times':msg_data.get('failed_times',0)+1, 'failed_reason':traceback.format_exc()})
					if msg_data.get('failed_times',0)<10:#最多失败10次，避免死循环
						self.queue.rpush(self.task_name,simplejson.dumps(msg_data))
					else:
						self.queue.lpush(self.task_name+'.response.failure', simplejson.dumps(msg_data) )
					print traceback.format_exc()
 
PingTask = TaskExecutor('PingTask')
 
@PingTask.task
def ping_url(url):
	import os
	os.system('ping -c 2 '+url)
 
if __name__=='__main__':
	PingTask.run()

运行服务：python TaskServer.py　　

ps:

　　　　1. TaskExecutor类是一个轻量级的celery.Celery实现。提供了 task修饰器。对被修饰的函数添加delay 方法（将原任务方法名/参数保存到redis的list中--FIFO--实际上celery也是类似的处理）

　　　　2. 客户端只要定义自己的TaskExecutor实例以及用此实例的task修饰对应的任务处理函数func。并在代码中待用 func.delay(...)实现异步调用（为了保证成功，最多调用10次）； 成功的记录会保存在 redis的 "任务名.response.success" 队列中, 超过10次仍然失败的保存在 “任务名.response.failure"队列中。

　　　　3. 待改进的地方是很多的， 比如多线程， 负载均衡。（尚未阅读celery源码）

　　TaskClient.py

# -*- coding:utf-8 -*-
import sys
sys.path.append('./')
from my_tasks import ping_url
ping_url.delay('www.baidu.com')

ps： 客户端和服务器文件在统一linux目录下。

　celery

　　试验证明， celery目测大体上跟上面的“基本处理过程”基本一致。即：

　　P将T保存在Q中。

　　C从Q中取出T处理（保证成功--会不会死循环？执行一个注定失败的任务--就没有验证了）。

　　celery的运用比较简单:

　　　　1.安装celery　　　

　　　　2.编写需要异步执行的任务函数，并用celery实例的task修饰器修饰

　　　　3.调用异步任务时， 用函数名.delay(参数）形式调用为异步调用。 函数名（参数）方式为同步调用。

　　　　4.执行celery监听服务

demo 这里有：http://www.jianshu.com/p/1840035cb510。 再来一个极简的：

　　　　tasks.py　　　

# -*- coding:utf-8 -*-
from celery import Celery
brokers = 'redis://127.0.0.1:6379/5'
backend = 'redis://127.0.0.1:6379/6'
 
import time
 
app = Celery('tasks', backend=backend, broker=brokers)
 
@app.task
def add(x,y):
    time.sleep(10)
    return x+y

运行celery监听服务：celery -A tasks worker -l error

　　　　

顺便附上测试代码：tasks_test.py(跟tasks.py同一路径，linux环境）

# -*- coding:utf-8 -*-
import sys
sys.path.append('./')
def test():
        from tasks import add
        for i in range(1000):
                add.delay(i,i+1)
 
if __name__=='__main__':
        test()

执行之 : python tasks_test.py

(可以1秒内跑完， 证明的确异步处理了）

顺便查看了下进程，发现celery自动开了一个主进程， 与cpu核数相同的子线程。看了下官方文档，有web监控用的插件（flower)。

安装: sudo pip install flower

运行之（跟tasks.py先同目录）： celery -A tasks flower --port=5555

效果图如下（木有发现失败任务--"Failed tasks"---很遗憾）：

　flower的基本原理推测是直接查询Q， 并基于结果输出图表等。

ref: https://abhishek-tiwari.com/post/amqp-rabbitmq-and-celery-a-visual-guide-for-dummies

　　转载请注明来源：http://www.cnblogs.com/Tommy-Yu/p/5955294.html

　　谢谢！