Celery在python中的应用

1. 什么是Celery

1.1 Celery

• Celery是一个简单、灵活且可靠的，处理大量消息的分布式系统，专注于实时处理的异步任务队列，同时也支持任务调度。

  

1.2 Celery的组成

• Celery的架构由三部分组成，消息中间件（message broker），任务执行单元（worker）和任务执行结果存储（task result store）组成。
  • 消息中间件：Celery本身不提供消息服务，但是可以方便的和第三方提供的消息中间件集成。包括，RabbitMQ, Redis等等
  • 任务执行单元：Worker是Celery提供的任务执行的单元，worker并发的运行在分布式的系统节点中。
  • 任务结果存储：Task result store用来存储Worker执行的任务的结果，Celery支持以不同方式存储任务的结果，包括AMQP, redis等
• 另外， Celery还支持不同的并发和序列化的手段
  • 并发：Prefork, Eventlet, gevent, threads/single threaded
  • 序列化：pickle, json, yaml, msgpack. zlib, bzip2 compression， Cryptographic message signing 等等

1.3 使用场景

• celery是一个强大的 分布式任务队列的异步处理框架，它可以让任务的执行完全脱离主程序，甚至可以被分配到其他主机上运行。我们通常使用它来实现异步任务（async task）和定时任务（crontab)。
  • 异步任务：将耗时操作任务提交给Celery去异步执行，比如发送短信/邮件、消息推送、音视频处理等等
  • 定时任务：定时执行某件事情，比如每天数据统计

1.4 Celery具有以下优点

Simple(简单)
Celery 使用和维护都非常简单，并且不需要配置文件。

Highly Available（高可用）
woker和client会在网络连接丢失或者失败时，自动进行重试。并且有的brokers 也支持“双主”或者“主／从”的方式实现高可用。

Fast（快速）
单个的Celery进程每分钟可以处理百万级的任务，并且只需要毫秒级的往返延迟（使用 RabbitMQ, librabbitmq, 和优化设置时）

Flexible（灵活）
Celery几乎每个部分都可以扩展使用，自定义池实现、序列化、压缩方案、日志记录、调度器、消费者、生产者、broker传输等等。

1.5 安装Celery

• pip安装

  pip insatll celery

• 源代码安装

  sudo easy_install Celery

2. Celery执行异步任务

2.1 创建一个简单的异步任务执行文件celery_task：

import celery
import time

# 任务结果储存，使用redis的1号仓库
backend = 'redis://127.0.0.1:6379/1'
# 消息中间件，使用redis的2号仓库
broker = 'redis://127.0.0.1:6379/2'

# 创建celery对象
cel = celery.Celery('test', backend=backend, broker=broker)


@cel.task
def send_email(name):
    print("向%s发送邮件..." % name)
    time.sleep(5)
    print("向%s发送邮件完成" % name)
    return "ok"

@cel.task
def send_message(name):
    print("向%s发送短信..." % name)
    time.sleep(5)
    print("向%s发送短信完成" % name)
    return "ok"

• 注意:创建完之后不要直接启动程序，在celery_task.py同级目录下打开终端执行:

  celery worker -A celery_task -l info

  

• 这条命令的作用: 内部会用Celery执行链接broker中的redis，然后创建一个消息队列，在启动多个worker来监听你的任务

• 日志上参数:

  • app: 项目名称
  • transport：消息中间件
  • results：任务结果存储
  • concurrency：并发数
  • [tasks] : 底下的是能够扫描到的异步任务

2.2 创建执行文件 produce_task:

from celery_task import send_email,send_message
# .delay是celery自带的参数
result = send_email.delay("yuan")
print(result.id)
result2 = send_message.delay("alex")
print(result2.id)

• 执行produce_task.py

  

• 会拿到两个id值，这个id值是存入到Task result store中，也就是在redis中，当业务中有需要调用到该id时可以直接通过访问redis调用，而且这个id不管任务有没有成功都会返回结果

• 在终端里:

  

  • 可以看到两个任务时同时发送的，并且5s之后同时完成，所以证明异步发送成功了

2.2.1 celery4.x在win10下报错解决

• 在win10下运行celery4.x会报如下的错

  • 

• 解决:

  • 安装eventlet

    pip install eventlet
    

  • 启动worker加参数

    celery worker -A celery_task -l info -P eventlet
    

  • 两种情况: 1.报错解除，可以执行worker 2. 继续报错，报错如下

    

  • 查看之前安装的eventlet版本，默认安装的是eventlet==0.27.0,卸载安装eventlet==0.26.0

    pip install eventlet==0.26.0
    

  • 最后执行:

    celery worker -A celery_task -l info -P eventlet
    

    

2.3 创建文件 result.py 查看执行结果:

from celery.result import AsyncResult
from celery_task import cel

# id就是之前的执行结果，也就是才能存入redis的key
# 通过AsyncResult调出结果,app是设置celery对象
async_result=AsyncResult(id="c6ddd5b7-a662-4f0e-93d4-ab69ec2aea5d", app=cel)

if async_result.successful():
    result = async_result.get()
    print(result)
   # 成功则返回ok 
    # result.forget() # 将结果删除
elif async_result.failed():
    print('执行失败')
elif async_result.status == 'PENDING':
    print('任务等待中被执行')
elif async_result.status == 'RETRY':
    print('任务异常后正在重试')
elif async_result.status == 'STARTED':
    print('任务已经开始被执行')

3. 多任务结构

3.1 创建新项目

• 目录结构：

3.2 代码实现

• celery.py(默认配置):

  from celery import Celery
  
  cel = Celery('celery_demo',
               broker='redis://127.0.0.1:6379/1',
               backend='redis://127.0.0.1:6379/2',
               # 包含以下两个任务文件，去相应的py文件中找任务，对多个任务做分类
               include=['celery_tasks.task01',
                        'celery_tasks.task02'
                        ])
  
  # 时区
  cel.conf.timezone = 'Asia/Shanghai'
  # 是否使用UTC
  cel.conf.enable_utc = False
  

• task01.py,task02.py(任务)：

  # task01
  import time
  from .celery import cel
  
  @cel.task
  def send_email(res):
      print("完成向%s发送邮件任务"%res)
      time.sleep(5)
      return "邮件完成"
  
  
  # task02
  import time
  from .celery import cel
  
  @cel.task
  def send_msg(res):
      print("完成向%s发送短信任务"%res)
      time.sleep(5)
      return "短信完成"
  

• produce_task.py(消费者):

  from celery_tasks.task01 import send_email
  from celery_tasks.task02 import send_msg
  
  # 立即告知celery去执行test_celery任务，并传入一个参数
  result = send_email.delay('yuan')
  print(result.id)
  result = send_msg.delay('yuan')
  print(result.id)
  

• check_result.py(结果获得):

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

4. 定时任务

• produce_task.py:

  from celery_task import send_email
  from datetime import datetime
  
  # 方式一
  # v1 = datetime(2020, 3, 11, 16, 19, 00)
  # print(v1)
  # v2 = datetime.utcfromtimestamp(v1.timestamp())
  # print(v2)
  # result = send_email.apply_async(args=["egon",], eta=v2)
  # print(result.id)
  
  # 方式二
  ctime = datetime.now()
  # 默认用utc时间
  utc_ctime = datetime.utcfromtimestamp(ctime.timestamp())
  from datetime import timedelta
  time_delay = timedelta(seconds=10)
  task_time = utc_ctime + time_delay
  
  # 使用apply_async并设定时间
  result = send_email.apply_async(args=["egon"], eta=task_time)
  print(result.id)
  

• 注意:这里我们可以看到定时任务和异步任务方法有一处不相同:

  # 异步任务
  send_email.delay('yuan')
  # 定时任务
  send_email.apply_async(args=["egon"], eta=task_time)
  本质上这两个方法一样，当 apply_async中没有传入eta,那就相当于 delay
  

5. 多目录下定时任务

• 多任务结构下的celery.py:

  from datetime import timedelta
  from celery import Celery
  from celery.schedules import crontab
  
  cel = Celery('tasks', broker='redis://127.0.0.1:6379/1', backend='redis://127.0.0.1:6379/2', include=[
      'celery_tasks.task01',
      'celery_tasks.task02',
  ])
  cel.conf.timezone = 'Asia/Shanghai'
  cel.conf.enable_utc = False
  
  cel.conf.beat_schedule = {
      # 名字随意命名
      'add-every-6-seconds': {
          # 执行tasks1下的test_celery函数
          'task': 'celery_tasks.task01.send_email',
          # 每隔2秒执行一次
          # 'schedule': 1.0,
          # 'schedule': crontab(minute="*/1"),
          'schedule': timedelta(seconds=6),
          # 传递参数
          'args': ('张三',)
      },
      # 'add-every-12-seconds': {
      #     'task': 'celery_tasks.task01.send_email',
      #     每年4月11号，8点42分执行
      #     'schedule': crontab(minute=42, hour=8, day_of_month=11, month_of_year=4),
      #     'args': ('张三',)
      # },
  } 
  

• 启动worker进程:celery worker -A celery_tasks -l info -P eventlet

• 启动Beat进程: celery beat -A celery_tasks

5.2 代码解释

• 当开启Beat进程他会不断的往消息队列里放入任务，然后等worker进程开启后会在消息队列里取任务，所以当Beat进程往borker里放入很多任务，worker进程没开启时，他会在borker里积攒这些任务，等到worker进程开启在执行，但当worker进程检测到borker里有大量任务时，worker会开启多个线程来执行任务，所以你可能会看到下面的结果:

  

• 关于worker: 这里可以通过加上个c参数来控制开启的线程数

  • celery worker -A celery_tasks -l info -P eventlet -c 4

• 解决:

  • 任务存储到redis中，我们可以通过连接redis来将其任务的key全删除就可以了

  • 创建 redis_test.py:

    import redis
    
    # 注意任务存储的是之前指定的1号仓库，所以这里要通过db来指定仓库
    redb = redis.Redis(host="127.0.0.1", port=6379, db=1)
    # redb.delete("celery")
    for i in redb.lrange("celery", 0, -1):
        print(i)
    

• 执行完上面的步骤在重新开启worker进程和Beat进程就可以看到定时任务

6. Django中使用Celery

6.1 创建新的Django项目

• 目录结果:

  

6.2 文件代码

• config.py(配置文件)

  broker_url = 'redis://127.0.0.1:6379/15'
  result_backend = 'redis://127.0.0.1:6379/14'
  

• main.py(主程序)

  # 主程序
  import os
  from celery import Celery
  # 创建celery实例对象
  app = Celery("sms")
  
  # 把celery和django进行组合，识别和加载django的配置文件
  os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'celeryPros.settings.dev')
  
  # 通过app对象加载配置
  app.config_from_object("mycelerys.config")
  
  # 加载任务
  # 参数必须必须是一个列表，里面的每一个任务都是任务的路径名称
  # app.autodiscover_tasks(["任务1","任务2"])
  app.autodiscover_tasks(["mycelerys.sms",])
  
  # 启动Celery的命令
  # 强烈建议切换目录到mycelery根目录下启动
  # celery -A mycelery.main worker --loglevel=info -P eventlet
  

• tasks.py(任务文件)

  # celery的任务必须写在tasks.py的文件中，别的文件名称不识别!!!
  from mycelerys.main import app
  import time
  
  
  import logging
  log = logging.getLogger("django")
  
  @app.task  # name表示设置任务的名称，如果不填写，则默认使用函数名做为任务名
  def send_sms(mobile):
      """发送短信"""
      print("向手机号%s发送短信成功!"%mobile)
      time.sleep(5)
  
      return "send_sms OK"
  
  @app.task  # name表示设置任务的名称，如果不填写，则默认使用函数名做为任务名
  def send_sms2(mobile):
      print("向手机号%s发送短信成功!" % mobile)
      time.sleep(5)
  
      return "send_sms2 OK"
  

  • 注意，任务文件必须为tasks.py，当有多个任务时，要重新创建python包，在包下创建tasks.py文件

• Django视图调用，views.py

  from datetime import datetime,timedelta
  
  from django.http import HttpResponse
  from django.shortcuts import render
  from mycelerys.sms.tasks import send_sms, send_sms2
  
  
  def test(request):
      # 异步任务
      # send_sms.delay("110")
      # send_sms2.delay("119")
      # send_sms.delay() 如果调用的任务函数没有参数，则不需要填写任何内容
  
      # 定时任务
      ctime = datetime.now()
      # 默认用utc时间
      utc_ctime = datetime.utcfromtimestamp(ctime.timestamp())
      time_delay = timedelta(seconds=10)
      task_time = utc_ctime + time_delay
      result = send_sms.apply_async(["911", ], eta=task_time)
      print(result.id)
      return HttpResponse("ok")
  

代码参考:cnblogs.com/pyedu/p/12461819.html

视频:https://www.bilibili.com/video/BV1Pa4y1Y7QN?p=6