来个芹菜，Celery的使用

1、写在前面

最近的flask项目遇到一些需要并发的情况，开始图省事，直接搞上了多线程，但是多线程的并发量很小，不利于扩展。

所以学习一下Celery的使用

2、基础概念

Celery是一个强大的分布式任务队列，他可以让任务的执行完全脱离主程序，甚至可以被分配到其他主机上运行。通常用来实现异步任务和定时任务。异步任务比如发送邮件，文件上传图像处理等；定时任务就是需要在特定时间执行的任务。

 

 

• 任务队列
  任务队列是一种跨线程，跨机器工作的一种机制，任务队列中包含称作任务的工作单元。有专门的工作进程持续不断的监视任务队列，并从中获取新的任务并处理。
• 任务模块
  包含异步任务和定时任务。异步任务通常在业务逻辑中被触发并发往任务队列；定时任务由Celery Beat进程周期性地将任务发往任务队列。
• 消息中间件Broker
  Broker，就是任务调度队列，接收任务生产者发来的消息（任务），将任务存入到队列。Celery本身不提供队列服务，官方推荐使用RabbitMQ和Redis等。
• 任务执行单元Worker
  Worker是执行任务的处理单元，它实时监控消息队列，获取队列中调度的任务，并执行它。
• 任务结果存储Backend
• Backend用于存储任务的执行结果，以供查询。同消息中间件一样，也可使用RabbitMQ和Redis，MySql等。

3、demo代码

3.1 异步任务

# -*- coding: utf-8 -*-

"""
Celery主类
启动文件名必须为celery.py！！！
"""

from __future__ import absolute_import  # 为兼容Python版本，绝对引入
from celery import Celery, platforms

app = Celery(
    main='celery_task',  # celery启动包名称
    broker='redis://127.0.0.1:6379/1',
    backend='redis://127.0.0.1:6379/2',
    include=['celery_task.tasks', ]  # celery所有任务
)

if __name__ == '__main__':
    app.start()

# -*- coding: utf-8 -*-

"""
定义任务
"""

from __future__ import absolute_import
from celery import Celery, group
from .celery import app
from time import sleep


@app.task
def add(x, y):
    sleep(5)
    return x + y


@app.task
def substract(x, y):
    sleep(5)
    return x - y

# -*- coding: utf-8 -*-

from celery_task.tasks import add,substract

# 立即告知celery去执行test_celery任务，并传入一个参数
result1 = add.delay(5,5)
print(result1.id)
result2 = substract.delay(5,5)
print(result2.id)

# -*- coding: utf-8 -*-

from celery.result import AsyncResult
from celery_task.celery import app

'''
获取任务结果，但要想办法获取到task_id
'''

async = AsyncResult(id='8d04fc47-0f72-49a1-a58a-b74e28eb9a41', app=app)

if async.successful():
    result = async.get()
    print(result)
    # result.forget() # 将结果删除,执行完成，结果不会自动删除
    # async.revoke(terminate=True)  # 无论现在是什么时候，都要终止
    # async.revoke(terminate=False) # 如果任务还没有开始执行呢，那么就可以终止。
elif async.failed():
    print('执行失败')
elif async.status == 'PENDING':
    print('任务等待中被执行')
elif async.status == 'RETRY':
    print('任务异常后正在重试')
elif async.status == 'STARTED':
    print('任务已经开始被执行')

执行步骤

• 在celery_test目录下cmd执行celery worker -A celery_task  -l info -P eventlet，开启worker，异步等待任务到来
• 执行send_tasks.py，将发布任务(任务写入borker)
• 等待一段时间后，可以在celery命令行看到执行结果
• 执行get_result.py获取执行结果

3.2 定时任务

 

# -*- coding: utf-8 -*-

# 拒绝隐式引入，如果celery.py和celery模块名字一样，避免冲突，需要加上这条语句
# 该代码中，名字是不一样的，最好也要不一样
from __future__ import absolute_import
from celery import Celery

app = Celery('celery_tasks')
app.config_from_object('celery_test2.config')

# -*- coding: utf-8 -*-

from __future__ import absolute_import
from celery.schedules import crontab
from datetime import timedelta

# 使用redis存储任务队列
broker_url = 'redis://127.0.0.1:6379/7'
# 使用redis存储结果
result_backend = 'redis://127.0.0.1:6379/8'

task_serializer = 'json'
result_serializer = 'json'
accept_content = ['json']
# 时区设置
timezone = 'Asia/Shanghai'
# celery默认开启自己的日志
# False表示不关闭
worker_hijack_root_logger = False
# 存储结果过期时间，过期后自动删除
# 单位为秒
result_expires = 60 * 60 * 24

# 导入任务所在文件
imports = [
    'celery_test2.celery_task2.task1',
    'celery_test2.celery_task2.task2'
]

# 需要执行任务的配置
beat_schedule = {
    'task1': {
        # 具体需要执行的函数
        # 该函数必须要使用@app.task装饰
        'task': 'celery_test2.celery_task2.task1.add',
        # 定时时间
        # 每分钟执行一次，不能为小数
        'schedule': crontab(minute='*/1'),
        # 或者这么写，每小时执行一次
        # "schedule": crontab(minute=0, hour="*/1")
        # 执行的函数需要的参数
        'args': (5,5)
    },
    'task2': {
        'task': 'celery_test2.celery_task2.task2.substract',
        # 设置定时的时间，10秒一次
        'schedule': timedelta(seconds=10),
        'args': (5,5)
    }
}

# -*- coding: utf-8 -*-
from .. import app
from time import sleep

@app.task
def add(x, y):
    sleep(5)
    print('add')
    return x + y

# -*- coding: utf-8 -*-
from .. import app
from time import sleep

@app.task
def substract(x, y):
    sleep(5)
    print(substract)
    return x - y

执行步骤

• 在celery_test2的同级目录下cmd执行celery -A celery_test2 worker -l info -P eventlet，开启worker，异步等待任务到来
• 在celery_test2的同级目录下cmd执行celery -A celery_test2 beat，发送定时任务，定时像borker推送任务
• 可在backend中查看执行结果，task_id

4、应用代码

4.1 Flask结合Celery，实现进度下载进度条

 

#coding=utf-8
from flask import Flask,url_for,jsonify,render_template
from celery import Celery
import random,time

app = Flask(__name__)

app.config['CELERY_BROKER_URL'] = 'redis://127.0.0.1:6379/1'
app.config['CELERY_RESULT_BACKEND'] = 'redis://127.0.0.1:6379/2'

#celery初始化
celery_obj = Celery(app.name,
                    broker=app.config['CELERY_BROKER_URL'],
                    backend=app.config['CELERY_RESULT_BACKEND'] )

@app.route('/')
def hello_world():
    return 'Hello World!'

@app.route('/nanobar')
def nanobar():
    return render_template('nanobar.html')

@app.route('/longtask', methods=['POST'])
def longtask():
    #发布任务，类似于long_task.delay()
    task1 = long_task.apply_async()
    # 返回 202，与Location头，构建/status/task_id路由
    return jsonify({}), 202, {'Location': url_for('taskstatus',task_id=task1.id)}

#通过task_id获取任务结果
@app.route('/status/<task_id>')
def taskstatus(task_id):
    task = long_task.AsyncResult(task_id)
    if task.state == 'PENDING':
        response = {
            'state': task.state,
            'current': 0,
            'total': 1,
            'status': 'Pending...'
        }
    elif task.state != 'FAILURE':
        response = {
            'state': task.state,
            'current': task.info.get('current', 0),
            'total': task.info.get('total', 1),
            'status': task.info.get('status', '')
        }
        if 'result' in task.info:
            response['result'] = task.info['result']
    else:
        # something went wrong in the background job
        response = {
            'state': task.state,
            'current': 1,
            'total': 1,
            'status': str(task.info),  # this is the exception raised
        }
    return jsonify(response)


# 通过 celery_obj.task 装饰器装饰耗时任务对应的函数
# bind为True，会传入self给被装饰的方法
#Celery有很多内建状态比如 STARTED ,  SUCCESS 等等，当然Celery也允许程序员自定义状态。
# 本例子中使用的是自定义状态， PROGRESS 。与 PROGRESS 一起的还有 metadata 。
# metadata 是一个字典，包含当前进度，任务大小，以及消息。
#当循环跳出时，返回字典，字典中包含任务的执行结果。
@celery_obj.task(bind=True)
def long_task(self):
    """随机列表"""
    list1 = ['列表1-1', '列表1-2', '列表1-3', '列表1-4', '列表1-5']
    list2 = ['列表2-1', '列表2-2', '列表2-3', '列表2-4', '列表2-5']
    list3 = ['列表3-1', '列表3-2', '列表3-3', '列表3-4', '列表3-5']
    message = ''
    #模拟一个随机耗时的任务
    total = random.randint(10, 50)
    for i in range(total):
        if not message or random.random() < 0.25:
            message = '{0} {1} {2}...'.format(random.choice(list1),
                                              random.choice(list2),
                                              random.choice(list3))
        #每次将状态更新
        self.update_state(state='PROGRESS',
                          meta={'current': i, 'total': total,'status': message})
        time.sleep(1)
    #跳出循环，代表任务结束
    return {'current': 100, 'total': 100, 'status': '任务完成!','result': 666}



if __name__ == '__main__':
    app.run(debug=True)

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script src="//cdnjs.cloudflare.com/ajax/libs/nanobar/0.2.1/nanobar.min.js"></script>
<script src="//cdnjs.cloudflare.com/ajax/libs/jquery/2.1.3/jquery.min.js"></script>
</head>
<body>
    <h2>进度条测试</h2>
    <button id="start-bg-job" onclick="start_long_task()">点击开始</button><br><br>
    <div id="progress"></div>
</body>

<script>
//点击后添加进度条，并开始异步任务
function start_long_task() {
        // 添加进度条
        div = $('<div class="progress"><div></div><div>0%</div><div>...</div><div>&nbsp;</div></div><hr>');
        $('#progress').append(div);

        // 进度条
        var nanobar = new Nanobar({
            bg: '#44f',
            target: div[0].childNodes[0]
        });

        // 向后端/longtask发送请求，发布任务，获得task_id，开始更新进度条
        $.ajax({
            type: 'POST',
            url: '/longtask',
            success: function(data, status, request) {
                status_url = request.getResponseHeader('Location');
                update_progress(status_url, nanobar, div[0]);
            },
            error: function() {
                alert('Unexpected error');
            }
        });
    };

    function update_progress(status_url, nanobar, status_div) {
        // 请求后端
        $.getJSON(status_url, function(data) {
            // 更新进度条
            percent = parseInt(data['current'] * 100 / data['total']);
            nanobar.go(percent);
            $(status_div.childNodes[1]).text(percent + '%');
            $(status_div.childNodes[2]).text(data['status']);
            //任务完成，添加结果
            if (data['state'] != 'PENDING' && data['state'] != 'PROGRESS') {
                if ('result' in data) {
                    // show result
                    $(status_div.childNodes[3]).text('Result: ' + data['result']);
                }
                else {
                    // 没有result代表任务异常
                    $(status_div.childNodes[3]).text('Result: ' + data['state']);
                }
            }
            else {
                // 任务未完成，每1秒递归执行函数
                setTimeout(function() {
                    update_progress(status_url, nanobar, status_div);
                }, 1000);
            }
        });
    };
</script>
</html>

执行步骤

• 在flask_tesk的同级目录下cmd执行celery -A app.celery_obj worker -l info -P eventlet，开启worker，异步等待任务到来
• python app.py run开启web应用
• 前端点击按钮，访问/longtask，发布任务，获取task_id，执行update_progress函数
• update_progress访问/status/task_id，获取任务结果，没有结束则每一秒递归运行
• 任务结束后，展示任务结果