java 分布式任务队列_分布式任务队列Celery

分布式任务队列Celery

Celery (芹菜)是基于Python开发的分布式任务队列。它支持使用任务队列的方式在分布的机器／进程／线程上执行任务调度。

结构

核心部件

broker

消息队列，由第三方消息中间件完成

常见有RabbitMQ, Redis, MongoDB等

worker

任务执行器

可以有多个worker进程

worker又可以起多个queue来并行消费消息

backend

后端存储，用于持久化任务执行结果

功能部件

beat

定时器，用于周期性调起任务

flower

web管理界面

任务

基本用法是在程序里引用celery，并将函数方法绑定到task

from celery import Celery

app = Celery('tasks', backend='amqp', broker='amqp://guest@localhost//')

app.conf.CELERY_RESULT_BACKEND = 'db+sqlite:///results.sqlite'

@app.task

def add(x, y):

return x + y

然后调用相应方法即可(delay与apply_async都是异步调用)

from tasks import add

import time

result = add.delay(4,4)

while not result.ready():

print "not ready yet"

time.sleep(5)

print result.get()

由于是采用消息队列，因此任务提交之后，程序立刻返回一个任务ID。

之后可以通过该ID查询该任务的执行状态和结果。

关联任务

执行1个任务，完成后再执行第2个，第一个任务的结果做第二个任务的入参

add.apply_async((2, 2), link=add.s(16))

结果：2+2+16=20

还可以做错误处理

@app.task(bind=True)

def error_handler(self, uuid):

result = self.app.AsyncResult(uuid)

print('Task {0} raised exception: {1!r}\n{2!r}'.format(

uuid, result.result, result.traceback))

add.apply_async((2, 2), link_error=error_handler.s())

定时任务

让任务在指定的时间执行，与下文叙述的周期性任务是不同的。

ETA, 指定任务执行时间,注意时区

countdown, 倒计时,单位秒

from datetime import datetime, timedelta

tomorrow = datetime.utcnow() + timedelta(seconds=3)

add.apply_async((2, 2), eta=tomorrow)

result = add.apply_async((2, 2), countdown=3)

tip

任务的信息是保存在broker中的，因此关闭worker并不会丢失任务信息

回收任务(revoke)并非是将队列中的任务删除，而是在worker的内存中保存回收的任务task-id，不同worker之间会自动同步上述revoked task-id。

由于信息是保存在内存当中的，因此如果将所有worker都关闭了，revoked task-id信息就丢失了，回收过的任务就又可以执行了。要防治这点，需要在启动worker时指定一个文件用于保存信息

celery -A app.celery worker --loglevel=info &> celery_worker.log --statedb=/var/tmp/celery_worker.state

过期时间

expires单位秒，超过过期时间还未开始执行的任务会被回收

add.apply_async((10, 10), expires=60)

重试

max_retries:最大重试次数

interval_start:重试等待时间

interval_step:每次重试叠加时长，假设第一重试等待1s，第二次等待1＋n秒

interval_max:最大等待时间

add.apply_async((2, 2), retry=True, retry_policy={

'max_retries': 3,

'interval_start': 0,

'interval_step': 0.2,

'interval_max': 0.2,

})

序列化

将任务结果按照一定格式序列化处理，支持pickle, JSON, YAML and msgpack

add.apply_async((10, 10), serializer='json')

压缩

将任务结果压缩

add.apply_async((2, 2), compression='zlib')

任务路由

使用-Q参数为队列(queue)命名，然后调用任务时可以指定相应队列

$ celery -A proj worker -l info -Q celery,priority.high

add.apply_async(queue='priority.high')

工作流

按照一定关系一次调用多个任务

group: 并行调度

chain: 串行调度

chord: 类似group，但分header和body2个部分，header可以是一个group任务，执行完成后调用body的任务

map: 映射调度，通过输入多个入参来多次调度同一个任务

starmap: 类似map，入参类似＊args

chunks:将任务按照一定数量进行分组

group

from celery import group

>>> res = group(add.s(i, i) for i in xrange(10))()

>>> res.get(timeout=1)

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

chain

>>> from celery import chain

# 2 + 2 + 4 + 8

>>> res = chain(add.s(2, 2), add.s(4), add.s(8))()

>>> res.get()

16

可以用｜来表示chain

# ((4 + 16) * 2 + 4) * 8

>>> c2 = (add.s(4, 16) | mul.s(2) | (add.s(4) | mul.s(8)))

>>> res = c2()

>>> res.get()

chord

>>> from celery import chord

#1*2+2*2+...9*2

>>> res = chord((add.s(i, i) for i in xrange(10)), xsum.s())()

>>> res.get()

90

map

>>> from proj.tasks import add

>>> ~xsum.map([range(10), range(100)])

[45, 4950]

starmap

>>> ~add.starmap(zip(range(10), range(10)))

[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

chunks

>>> from proj.tasks import add

>>> res = add.chunks(zip(range(100), range(100)), 10)()

>>> res.get()

[[0, 2, 4, 6, 8, 10, 12, 14, 16, 18],

[20, 22, 24, 26, 28, 30, 32, 34, 36, 38],

[40, 42, 44, 46, 48, 50, 52, 54, 56, 58],

[60, 62, 64, 66, 68, 70, 72, 74, 76, 78],

[80, 82, 84, 86, 88, 90, 92, 94, 96, 98],

[100, 102, 104, 106, 108, 110, 112, 114, 116, 118],

[120, 122, 124, 126, 128, 130, 132, 134, 136, 138],

[140, 142, 144, 146, 148, 150, 152, 154, 156, 158],

[160, 162, 164, 166, 168, 170, 172, 174, 176, 178],

[180, 182, 184, 186, 188, 190, 192, 194, 196, 198]]

周期性任务

周期性任务就是按照一定的时间检查反复执行的任务。前面描述的定时任务值的是一次性的任务。

程序中引入并配置好周期性任务后，beat进程就会定期调起相关任务

beat进程是需要单独启动的

$ celery -A proj beat

或者在worker启动时一起拉起

$ celery -A proj worker -B

注意一套celery只能启一个beat进程

时区配置

由于python中时间默认是utc时间，因此最简便的方法是celery也用utc时区

CELERY_TIMEZONE = 'UTC'

这么配置可以保证任务调度的时间是准确的，但由于服务器一般都配置时区，因此flower、以及日志中的时间可能会有偏差

另外一种方法，就是配置正确的时区

CELERY_TIMEZONE = 'Asia/Shanghai'

然后任务调起时，将时间带入时区配置

local_tz = pytz.timezone(app.config['CELERY_TIMEZONE'])

format_eta = local_tz.localize(datetime.strptime(eta.strip(), '%Y/%m/%d %H:%M:%S'))

add.apply_async((2, 2),eta=format_eta)

周期性任务配置

from datetime import timedelta

CELERYBEAT_SCHEDULE = {

'add-every-30-seconds': {

'task': 'tasks.add',

'schedule': timedelta(seconds=30),

'args': (16, 16)

},

}

周期性任务配置crontab

from celery.schedules import crontab

CELERYBEAT_SCHEDULE = {

# Executes every Monday morning at 7:30 A.M

'add-every-monday-morning': {

'task': 'tasks.add',

'schedule': crontab(hour=7, minute=30, day_of_week=1),

'args': (16, 16),

},

}

总结

celery功能非常强大，与django、flask等web应用配合相得益彰，推荐给大家。

本文参考官方文档