Celery原理使用介绍
celery（超详细）
celery（超详细）相关概念: 解耦: 将耗时的发短信任务逻辑从主逻辑中分离出来的动作, 让响应不受耗时任务的影响 ⽣产者消费者设计模式: 最常⽤的解耦模式 ⽣产者 ==> ⽣成任务,消息 消息队列 ==> 缓存任务,消息 消费者 ==> 执⾏任务,消息 实现: 让⽣产者⽣成发短信任务,再把任务放在消息队列⾥⾯,最后由消费者执⾏任务1. celery简介: celery 是⼀个简单、灵活且可靠、处理⼤量消息的分布式系统，可以在⼀台或者多台机器上运⾏ 特点：单个 Celery 进程每分钟可处理数以百万计的任务. 通过消息进⾏通信，使⽤消息队列（中间⼈或broker）在⽣产者和消费者之间协调2. 使⽤场景:异步任务：将耗时操作任务提交给Celery去异步执⾏，⽐如发送短信/邮件、消息推送、⾳视频处理等等定时任务：定时执⾏某件事情，⽐如每天数据统计3. 使⽤实例(短信验证码异步):1）安装2) 创建实例并配置: a.定义celery包：在项⽬外层增加⼀个celery_tasks包或者⽂件夹 b.创建celery实例：在celery_tasks中添加 main.py⽂件名称') #名称是⾃⼰取的 c.加载celery配置：在celery_tasks包中添加config.py⽂件在⽂件中指定消息队列（中间⼈）使⽤redis 作为中间⼈ broker_url = 'redis://127.0.0.1:6379/3' 使⽤rabbitmq 作为中间⼈ broker_url='amqp://⽤户名:密码@ip地址:5672' ⽰例： # 例如: # meihao: 在rabbitq中创建的⽤户名, 注意: 远端链接时不能使⽤guest账户. # 123456: 在rabbitq中⽤户名对应的密码 # ip部分: 指的是当前rabbitq所在的电脑ip # 5672: 是规定的端⼝号 broker_url ='amqp://meihao:123456@172.16.238.128:5672' d. 在celery_tasks.main.py 中, 将刚刚的config配置给 celery e. 定义任务：注册任务：在celery_tasks包下在创建⼀个包名字随意(在这⾥我们创建sms包)创建好后，在⾥⾯添加⼀个tasks.py⽂件（tasks⽂件名不能改）然后再，celery_tasks.main.py报备刚刚创建的⽂件#⾃动获取tasks celery_app.autodiscover_tasks(['celery_tasks.sms'])实现任务：在celery_tasks.sms.tasks.py⽂件中添加如下代码：result = CCP().send_tempalte_sms(mobile, [sms_code, 5], 1) # 这个⽅法需要从yuntongxun⾥导⼊ return result注意: 真实的开发环境有可能会把 celery_tasks 单独拿到某⼀个电脑上独⽴执⾏,可以把yuntongxun 复制⼀份, 放到 celery_tasks 下⾯, 拿⾛的时候, 直接调⽤⾛就可以4. 可能需要的操作命令启动celery： celery -A celery_tasks.main worker -l info补充celery worker的⼯作模式 指定进程数： celery worker -A proj --concurrency=4 改变进程池⽅式为协程⽅式： celery worker -A proj --concurrency=1000 -P evenlet -c 1000 安装 evenlet 模块： pip install eventlet 启⽤ eventlet 池： celery -A celery_tasks.main worker -l info -P eventlet -c 1000 windows10启⽤celery：celery -A celery_tasks.main worker -l info -P eventlet。
celery高级用法
celery高级用法摘要：1.Celery 概述2.Celery 高级用法：任务链、任务队列、定时任务、错误处理3.实战示例：使用Celery 进行异步任务处理正文：一、Celery 概述Celery 是一个基于Python 的异步任务队列库，可以方便地实现任务的异步执行，提高程序的运行效率。
通过Celery，我们可以将耗时的任务封装成一个个任务，将它们添加到队列中，然后让Celery 在后台处理这些任务。
二、Celery 高级用法：任务链、任务队列、定时任务、错误处理1.任务链任务链是Celery 中的一种高级用法，它允许将多个任务按照特定的顺序串联起来。
任务链中的每个任务都会在前一个任务完成后自动开始执行。
要实现任务链，我们需要使用`chain()`方法。
2.任务队列Celery 提供了任务队列的功能，可以将任务添加到队列中，然后让Celery 在后台处理这些任务。
任务队列可以有效地解决多任务并发执行的问题，提高程序的运行效率。
3.定时任务Celery 支持定时任务，可以在特定的时间点执行任务。
要实现定时任务，我们需要使用`schedule`装饰器。
4.错误处理在Celery 中，我们可以使用`apply_async`方法的`link_error`参数来设置任务执行过程中出现错误时的处理方式。
三、实战示例：使用Celery 进行异步任务处理假设我们有一个耗时任务，需要对一个文件进行处理，我们可以使用Celery 来实现这个任务的异步执行。
1.首先，安装Celery 库，并创建一个Celery 实例。
2.定义一个任务类，继承自`celery.Task`。
3.在任务类中，实现任务的具体操作。
4.创建一个任务队列。
5.将任务添加到队列中，并使用`apply_async`方法启动任务。
6.使用`AsyncResult`对象来获取任务的执行结果。
通过以上步骤，我们可以实现一个简单的Celery 异步任务处理示例。
python celery应用场景
python celery应用场景一、什么是Python CeleryPython Celery是一个基于分布式消息传递的任务队列/异步任务处理框架，它可以让开发者轻松地将耗时的任务放到后台执行，从而提高应用的性能和可扩展性。
二、Python Celery的应用场景1. 异步任务处理Python Celery最常见的应用场景就是异步任务处理。
例如，当用户提交了一个需要进行长时间计算的请求时，我们可以将这个请求放到Celery队列中，然后返回一个立即响应给用户。
在后台中，Celery会自动地调度和执行这个任务，并在完成后通知客户端。
2. 定时任务调度Python Celery还可以用来进行定时任务调度。
例如，在某些情况下，我们需要定期地从数据库中读取数据并进行一些特定操作。
使用Celery可以轻松地实现这个功能，并且不会影响主线程的运行。
3. 分布式计算如果需要进行大规模的分布式计算，Python Celery也是一个不错的选择。
通过将计算任务分配到多个节点上执行，可以大幅提高计算速度。
4. 队列管理系统除此之外，Python Celery还可以作为队列管理系统使用。
例如，在电商平台上，我们需要对订单进行排队和处理。
使用Celery可以轻松地实现这个功能，并且可以根据实际情况动态地调整队列长度和处理速度。
三、Python Celery的使用方法1. 安装Celery在使用Python Celery之前，需要先安装相关的依赖包。
可以使用pip命令进行安装：```pip install celery2. 配置Celery在使用Celery之前，需要对其进行配置。
配置文件通常包含以下内容：- Broker URL：用于指定消息代理的地址，例如RabbitMQ、Redis 等。
- Result Backend：用于指定任务结果的存储方式，例如数据库、缓存等。
- Task Serializer：用于指定任务序列化方式，例如JSON、Pickle等。
celery分布式
celery分布式（实用版）目录1.Celery 简介2.Celery 的分布式特点3.Celery 的使用方法4.Celery 的优点和缺点5.Celery 的应用场景正文1.Celery 简介Celery 是一款基于 Python 的轻量级分布式任务队列，它可以让开发者轻松实现任务的分发和调度。
Celery 的出现，使得复杂的任务可以在多个服务器之间进行负载均衡，从而提高程序的运行效率。
2.Celery 的分布式特点Celery 具有以下几个显著的分布式特点：- 异步任务处理：Celery 可以将任务异步处理，从而避免阻塞主线程，提高程序运行效率。
- 分布式任务调度：Celery 支持在多个服务器之间进行任务调度，实现任务的负载均衡。
- 任务路由：Celery 可以根据任务类型和任务参数自动选择合适的任务节点进行处理。
- 任务优先级：Celery 支持任务优先级设置，可以根据优先级对任务进行排序和处理。
- 任务持久化：Celery 支持任务结果的持久化，可以防止任务数据丢失。
3.Celery 的使用方法要使用 Celery，首先需要安装 Celery 库。
在项目中，需要创建一个 Celery 实例，并配置相关参数，如任务路由、任务负载均衡等。
然后，需要在项目中编写任务代码，并使用 Celery 实例来调用任务。
4.Celery 的优点和缺点Celery 的优点包括：- 轻量级：Celery 的体积较小，对系统资源的占用较低。
- 分布式支持：Celery 可以轻松实现任务的分布式处理，提高程序运行效率。
- 丰富的功能：Celery 支持任务的异步处理、优先级设置、结果持久化等功能。
Celery 的缺点包括：- 学习成本：Celery 的使用需要一定的学习成本，开发者需要熟悉Celery 的配置和使用方法。
- 性能问题：在某些场景下，Celery 的性能可能不如其他任务队列工具。
5.Celery 的应用场景Celery 适用于以下场景：- 需要进行大量并发处理的程序，如网络爬虫、数据分析等。
celery高级用法
celery高级用法Celery 高级用法- 提升分布式任务调度的能力引言：随着系统规模的扩大和业务复杂度的增加，分布式任务调度变得越来越重要。
Celery 是一个强大的分布式任务调度框架，它提供了丰富的特性和高级用法，帮助开发者实现任务的并发执行、任务队列的管理、任务优先级的控制等，确保系统的性能、可扩展性和可靠性。
本文将一步一步介绍Celery 的高级用法，助你更好地运用Celery 构建高效的分布式任务调度系统。
第一部分：部署和配置Celery在开始介绍Celery 的高级用法之前，我们首先需要部署和配置Celery。
Celery 的部署可以使用多种方法，例如使用pip 安装，或者直接从源代码进行安装。
安装完成后，需要配置Celery 的参数，如任务队列的选择、任务超时时间、任务结果的存储方式等。
配置参数在Celery 的配置文件中进行设置，可以根据实际需求进行调整。
第二部分：任务的并发执行Celery 支持任务的并发执行，你可以通过多种方式来实现这一功能。
一种常见的方式是使用Celery 的worker pool。
worker pool 是由一组worker 组成的线程池，每个worker 可以执行一个任务。
你可以在启动worker 时设置worker pool 的大小，决定能够同时执行的任务数量。
另一种方式是使用Celery 的分布式worker。
分布式worker 可以运行在多台机器上，从而实现更大规模的任务并发执行。
第三部分：任务队列的管理Celery 提供了强大的任务队列管理功能，可以实现任务的优先级控制、队列长度限制和执行顺序的调整。
你可以在任务定义中设置任务的优先级，Celery 会根据任务的优先级决定任务的执行顺序。
此外，你还可以使用Celery 的rate limit 功能来限制每个worker 在一段时间内执行任务的数量。
如果队列中的任务数量超过了设置的阈值，你可以配置Celery 来拒绝新的任务提交，从而保证队列的长度不会无限增长。
celery --concurrency参数
celery --concurrency参数Celery是一个分布式任务队列框架，是用Python编写的，用来实现消息发送和处理的工具。
在使用Celery时，可以通过设置`--concurrency`参数来控制并发执行的进程数量。
本文将详细介绍`--concurrency`参数的作用和用法，以及其在实际应用中的一些注意事项。
首先，让我们来看看`--concurrency`参数的定义。
在Celery中，所有的任务都是由Worker来执行的。
`--concurrency`参数用于配置并发执行任务的进程数量。
它可以通过命令行参数或者配置文件进行设置。
例如，在命令行中可以使用以下命令来启动Celery Worker并设置并发执行任务的进程数量为4：```celery -A proj worker --concurrency=4```当然，也可以在配置文件中进行配置。
在Celery的配置文件中，可以添加如下配置项来设置并发执行的进程数量：```python# celeryconfig.pyconcurrency = 4```使用`--concurrency`参数可以控制并行执行任务的进程数量，从而提高系统的整体性能。
它可以根据系统的实际情况进行调整，以获得最佳的性能表现。
在实际应用中，我们可以通过不断调整`--concurrency`参数的值，来找到最合适的进程数量。
通常情况下，可以通过观察系统资源的使用情况，来确定并发执行任务的进程数量。
然而，需要注意的是，并发执行的进程数量并不是越多越好。
增加并发数可能会导致系统资源的消耗过大，甚至会导致系统的崩溃。
因此，我们必须根据系统资源的情况及任务的特点来合理地配置`--concurrency`参数。
一般来说，可以通过监控系统资源的使用情况，来确定系统的承载能力，从而确定适当的并发执行进程数量。
此外，在设置`--concurrency`参数时，还需要考虑任务的类型和特点。
celery result_serializer
celery result_serializer【原创实用版】目录1.Celery 简介2.ResultSerializer 的作用3.ResultSerializer 的使用方法4.示例正文1.Celery 简介Celery 是一个基于 Python 的异步任务队列库，可以用来处理大量的并发任务，从而提高应用程序的性能。
它具有强大的任务调度和执行能力，适用于许多场景，如电子邮件发送、文件处理、数据导入等。
2.ResultSerializer 的作用在 Celery 中，ResultSerializer 是一个非常有用的工具，它可以将异步任务的结果序列化为 JSON 格式，以便在任务完成后将其存储到数据库或其他存储系统中。
这样，我们可以轻松地处理和分析任务的结果，而不必担心任务结果的数据格式问题。
3.ResultSerializer 的使用方法要使用 ResultSerializer，首先需要安装 Celery 和相关的依赖库。
然后，按照以下步骤进行操作：(1) 在 Celery 配置文件中，启用 ResultSerializer。
例如，在Celery 的配置文件中添加以下代码：```from celery.concurrency import Sessionfrom celery.result import ResultSerializerSession = Session(bind=None,serializer=ResultSerializer(json_encode_kwargs=True)) ```这将启用 ResultSerializer，并将其设置为使用 JSON 编码。
(2) 在任务方法中，使用`apply_async`或`apply`方法来执行异步任务。
例如：```python@app.taskdef my_task(param):# 执行任务的逻辑result = "任务结果"return result```(3) 使用`AsyncResult.get()`方法来获取任务的结果。
celery使用详解
celery使⽤详解celery是啥？由python 编写的异步⽣产者消费者设计模式下的实例举个例⼦：现有两个进程⽣产者进程A 消费者进程B现在的情况是逻辑推导：A 产出栗⼦B 要吃栗⼦那么这两个进程必然是 B依赖于A 耦合度很⾼且是⼀个耗时操作B -----> （发送请求给A）------->(等待A 产出栗⼦也许会很久)------->(A响应栗⼦给B)------->（B得到栗⼦）B 可能是个很多服务的集成后台之类很忙⼤忙⼈不想⼀直等等等那么 celery 的任务就是替B 去等逻辑推导：A 产出栗⼦B 要吃栗⼦C celeryB (替我去取栗⼦)-----> C（发送请求给A）------->(等待A 产出栗⼦也许会很久)------->(A响应栗⼦给C)------->（B得到栗⼦） (C 可以去把栗⼦存在⼀个地⽅B直接去取就好了)那么celery 的本质知道了：⼀个中间⼈⾓⾊，类似快递⼩哥，跑腿的作⽤：1 防⽌线程阻塞提⾼性能2低耦合解耦⾼内聚⾼复⽤好处 ::每分钟可以实现数以百万的任务特点: 使⽤消息队列(broker )在客户端和消费者之间协调主体在消息队列还有协调两端可以有多个好的，现在说celery 的结构Celery的架构由三部分组成，消息中间件（message broker），任务执⾏单元（worker）和任务执⾏结果存储（task result store）组成。
消息中间件（message broker）：这个很好理解，B指派给C 的任务可能不只⼀件，所以celery 要把任务存起来⼀件⼀件去执⾏，存储⼀般是⽤消息队列结构的，celery 本⾝是不带存储空间的需要指派位置存包括，,,等ps : 队列也是⼀种数据结构 , 表现形式为⼀段进⼊,⼀段出先进先出, 不能再中间插⼊ ,类似管道任务执⾏单元（worker）： Worker是Celery提供的任务执⾏的单元，worker并发的运⾏在分布式的系统节点中（快递⼩哥本体）任务执⾏结果存储（task result store）：⼩哥把东西要放到快递柜咯这⾥也要⽤到其他服务包括Redis，MongoDB，Django ORM，AMQP等简单来说就是 broker 收集任务（收件）worker 执⾏任务存在 task result store （派送）这⾥主要使⽤rediscelery 简单配置# 安装celerysudo pip install celery -i https:///simple------配置信息 tasks.py-------BROKER_URL = 'redis://localhost:6379/0'# 格式 redis://:password@hostname:port/db_number 不过redis ⼀般不设密码from celery import Celeryapp = Celery("tasks", broker=BROKER_URL)@app.taskdef add(x,y):return x,y----------启动------$ celery -A tasks worker --loglevel=info#查询⽂档，了解到该命令中-A参数表⽰的是Celery APP的名称，这个实例中指的就是tasks.py,后⾯的tasks就是APP的名称，worker是⼀个执⾏任务⾓⾊，后⾯的loglevel=info记录⽇志类型默认是info,这个命令启动了⼀个worker,⽤来执⾏程序中add这个加法任务（task）。
celery
celery Celery的提供的定时任务主要靠schedules来完成，通过beat组件周期性将任务发送给woker执⾏。
在⽰例中，新建⽂件period_task.py，并添加任务到配置⽂件中：period_task.py：#!/usr/bin/env python3# -*- coding:utf-8 -*-# Author:wdfrom project import appfrom celery.schedules import crontab@app.on_after_configure.connectdef setup_periodic_tasks(sender, **kwargs):sender.add_periodic_task(10.0, add.s(1,3), name='1+3=') # 每10秒执⾏addsender.add_periodic_task(crontab(hour=16, minute=56, day_of_week=1), #每周⼀下午四点五⼗六执⾏sayhaisayhi.s('wd'),name='say_hi')@app.taskdef add(x,y):print(x+y)return x+y@app.taskdef sayhi(name):return 'hello %s' % nameconfig.py#!/usr/bin/env python3# -*- coding:utf-8 -*-# Author:wdBROKER_URL = 'redis://10.1.210.69:6379/0' # Broker配置，使⽤Redis作为消息中间件CELERY_RESULT_BACKEND = 'redis://10.1.210.69:6379/0' # BACKEND配置，这⾥使⽤redisCELERY_RESULT_SERIALIZER = 'json' # 结果序列化⽅案CELERY_TASK_RESULT_EXPIRES = 60 * 60 * 24 # 任务过期时间CELERY_TIMEZONE='Asia/Shanghai' # 时区配置CELERY_IMPORTS = ( # 指定导⼊的任务模块,可以指定多个'project.tasks','project.period_task', #定时任务)启动worker和beat：celery worker -A project -l debug #启动workcelery beat -A project.period_task -l debug #启动beat，注意此时对应的⽂件路径我们可以观察worker⽇志：还可以通过配置⽂件⽅式指定定时和计划任务,此时的配置⽂件如下：from project import appfrom celery.schedules import crontabBROKER_URL = 'redis://10.1.210.69:6379/0' # Broker配置，使⽤Redis作为消息中间件CELERY_RESULT_BACKEND = 'redis://10.1.210.69:6379/0' # BACKEND配置，这⾥使⽤redisCELERY_RESULT_SERIALIZER = 'json' # 结果序列化⽅案CELERY_TASK_RESULT_EXPIRES = 60 * 60 * 24 # 任务过期时间CELERY_TIMEZONE='Asia/Shanghai' # 时区配置CELERY_IMPORTS = ( # 指定导⼊的任务模块,可以指定多个'project.tasks','project.period_task',)app.conf.beat_schedule = {'period_add_task': { # 计划任务'task': 'project.period_task.add', #任务路径'schedule': crontab(hour=18, minute=16, day_of_week=1),'args': (3, 4),},'add-every-30-seconds': { # 每10秒执⾏'task': 'project.period_task.sayhi', #任务路径'schedule': 10.0,'args': ('wd',)},}此时的period_task.py只需要注册到woker中就⾏了，如下：#!/usr/bin/env python3# -*- coding:utf-8 -*-# Author:wdfrom project import app@app.taskdef add(x,y):print(x+y)return x+y@app.taskdef sayhi(name):return 'hello %s' % name Celery可通过任务绑定到实例获取到任务的上下⽂，这样我们可以在任务运⾏时候获取到任务的状态，记录相关⽇志等。
详解分布式任务队列Celery使用说明
详解分布式任务队列Celery使⽤说明起步Celery 是⼀个简单、灵活且可靠的，处理⼤量消息的分布式系统，并且提供维护这样⼀个系统的必需⼯具。
它是⼀个专注于实时处理的任务队列，同时也⽀持任务调度。
运⾏模式是⽣产者消费者模式：任务队列：任务队列是⼀种在线程或机器间分发任务的机制。
消息队列：消息队列的输⼊是⼯作的⼀个单元，称为任务，独⽴的职程（Worker）进程持续监视队列中是否有需要处理的新任务。
Celery ⽤消息通信，通常使⽤中间⼈（Broker）在客户端和职程间斡旋。
这个过程从客户端向队列添加消息开始，之后中间⼈把消息派送给职程，职程对消息进⾏处理。
Celery的架构由三部分组成，消息中间件（message broker），任务执⾏单元（worker）和任务执⾏结果存储（task result store）组成。
消息中间件：Celery本⾝不提供消息服务，但是可以⽅便的和第三⽅提供的消息中间件集成，包括，RabbitMQ, Redis, MongoDB等，本⽂使⽤ redis 。
任务执⾏单元：Worker是Celery提供的任务执⾏的单元，worker并发的运⾏在分布式的系统节点中任务结果存储：Task result store⽤来存储Worker执⾏的任务的结果，Celery⽀持以不同⽅式存储任务的结果，包括Redis，MongoDB，Django ORM，AMQP等，这⾥我先不去看它是如何存储的，就先选⽤Redis来存储任务执⾏结果。
安装通过 pip 命令即可安装：pip install celery本⽂使⽤ redis 做消息中间件，所以需要在安装：pip install redis简单的demo为了运⾏⼀个简单的任务，从中说明 celery 的使⽤⽅式。
在项⽬⽂件夹内创建 app.py 和 tasks.py 。
tasks.py ⽤来定义任务：# tasks.pyimport timefrom celery import Celerybroker = 'redis://127.0.0.1:6379/1'backend = 'redis://127.0.0.1:6379/2'app = Celery('my_tasks', broker=broker, backend=backend)@app.taskdef add(x, y):print('enter task')time.sleep(3)return x + y这些代码做了什么事。
异步任务（Celery）详解
异步任务（Celery）详解⼀、背景在开发中，我们可能经常会遇到⼀些需要执⾏时间很长的任务，如果放在前端，会让⽤户⼀直卡在那⼉等待或者⼀直转圈圈，体验⾮常不好。
为了改善这种体验，我赶紧上⽹搜索，果然，前⼈早已有解决办法了。
那就是异步。
在Django中，我们可以使⽤celery异步框架，我们可以把耗时的任务扔到后台，⽽前端给⽤户⽴即返回，待⽤户需要查看结果时，点击查看即可，并且可以随时看到任务执⾏的状态。
⼆、原理Celery是基于Python开发的⼀个分布式任务队列框架，⽀持使⽤任务队列的⽅式在分布的机器/进程/线程上执⾏任务调度。
它是Python写的库，但是它实现的通讯协议也可以使⽤ruby，php，javascript等调⽤。
异步任务除了消息队列的后台执⾏的⽅式，还是⼀种则是定时计划任务。
Celery 是⼀个强⼤的分布式任务队列，它可以让任务的执⾏完全脱离主程序，甚⾄可以被分配到其他主机上运⾏。
我们通常使⽤它来实现异步任务（async task）和定时任务（crontab）。
它的架构组成如下图组件：1、任务（tasks）--⽤户定义的函数，⽤于实现⽤户的功能，⽐如执⾏⼀个耗时很长的任务2、中间介（Broker）--⽤于存放tasks的地⽅，但是这个中间介需要解决⼀个问题，就是可能需要存放⾮常⾮常多的tasks，⽽且要保证Worker能够从这⾥拿取3、执⾏者（Worker）--⽤于执⾏tasks，也就是真正调⽤我们在tasks中定义的函数4、存储（Backend）--把执⾏tasks返回的结果进⾏存储，以供⽤户查看或调⽤三、实现1、各模块功能Celery中，以上组件具体功能如下：任务模块 Task包含异步任务和定时任务。
其中，异步任务通常在业务逻辑中被触发并发往任务队列，⽽定时任务由 Celery Beat 进程周期性地将任务发往任务队列。
消息中间件 BrokerBroker，即为任务调度队列，接收任务⽣产者发来的消息（即任务），将任务存⼊队列。
Celery的原理和应用场景
Celery的原理和应用场景1. Celery简介Celery是一个基于分布式消息传递的异步任务队列/任务调度器，使用Python 语言编写。
它可以实现任务的分布式调度、定时任务的调度以及任务的异步执行。
2. Celery的原理Celery的运行原理可以简单概括为以下几个步骤：1.创建任务：用户通过定义函数或方法作为任务，使用@celery.task装饰器标识任务，然后将任务注册到Celery中。
2.发送任务：当有任务需要执行时，任务的调用者将任务发送给Celery的消息队列（Broker），Broker可以是一种消息中间件，如RabbitMQ、Redis等。
3.任务队列：Celery的任务队列负责接收、存储和分发任务。
一旦有任务发送到队列中，Celery会自动为每个任务创建一个唯一的任务标识（Task ID）。
4.任务调度：Celery根据一系列的调度算法从任务队列中选择需要执行的任务，并将任务发送给可用的工作进程进行执行。
Celery支持不同的调度器，如Round Robin、负载均衡等。
5.执行任务：被选中的工作进程通过Broker获取任务并执行。
任务的执行过程可以是同步或异步的，任务执行的结果也可以被获取到。
6.任务结果：Celery支持将任务执行结果存储到后端数据库或消息队列中，用户可以通过任务标识查询任务的执行状态和结果。
3. Celery的应用场景Celery作为一个强大的任务队列框架，广泛应用于各种需要异步处理的场景，下面介绍几个常见的应用场景：3.1 异步任务处理在传统的Web应用中，有些任务耗时较长，如果同步执行会导致用户等待过长的时间。
使用Celery可以将这些耗时任务放入队列中，让用户无需等待，提高用户体验。
例如，在一个电商网站中，用户下单后需要发送邮件通知用户订单信息，发送邮件是一个耗时的操作。
这时可以将发送邮件的任务放入Celery队列中异步执行，用户无需等待邮件发送完成，可以继续浏览网站。
celery——任务调度模块
celery——任务调度模块Celery是Python开发的并⾏分布式任务调度模块，今天抽空看了⼀下，果然接⼝简单，开发容易，5分钟就写出了⼀个异步发送邮件的服务。
Celery本⾝不含消息服务，它使⽤第三⽅消息服务来传递任务，⽬前，Celery⽀持的消息服务有RabbitMQ、Redis甚⾄是数据库，当然Redis应该是最佳选择。
架构设计：架构组成：Celery的架构由三部分组成，消息中间件（message broker），任务执⾏单元（worker）和任务执⾏结果存储（task result store）组成。
消息中间件Celery本⾝不提供消息服务，但是可以⽅便的和第三⽅提供的消息中间件集成。
包括，, , (experimental), Amazon SQS(experimental), (experimental), (experimental),Django ORM (experimental),任务执⾏单元Worker是Celery提供的任务执⾏的单元，worker并发的运⾏在分布式的系统节点中。
任务结果存储Task result store⽤来存储Worker执⾏的任务的结果，Celery⽀持以不同⽅式存储任务的结果，包括AMQP, Redis，memcached, MongoDB，SQLAlchemy, Django ORM，Apache Cassandra, IronCache另外， Celery还⽀持不同的并发和序列化的⼿段并发, , , threads/single threaded序列化pickle, json, yaml, msgpack. zlib, bzip2 compression， Cryptographic message signing 等等1.安装Celery⽤pip或easy_install安装：$ sudo pip install Celery或者：$ sudo easy_install Celery使⽤Redis作为Broker时，再安装⼀个celery-with-redis。
celery--调用异步任务的三种方法和task参数
celery--调⽤异步任务的三种⽅法和task参数调⽤异步任务的三种⽅法第⼀种调⽤异步任务有三种⽅法，前⾯我们使⽤的是task.delay()，这是apply_async⽅法的别名，但接受的参数较为简单第⼆种我们常⽤的是task.apply_async(args=[arg1,args],kwargs={key:value})：可以接受复杂的参数这种可以接收的参数有：task_id：为任务分配唯⼀id，默认是uuidcountdown：设置该任务等待⼀段时间在执⾏，单位为秒eta：定义任务的开始时间，eta=time.time()+5，单位为秒，是UTC时间，设置成国内时间也没有⽤expires：设置任务过期时间，任务在过期时间后还没有执⾏则被丢弃，单位为秒retry：如果任务失败后，是否重试，默认为Trueshadow：重新指定任务的名字，覆盖其在⽇志中使⽤的任务名称retry_policy:{} 重试策略，max_retries:最⼤重试次数，默认为3次。
interval_start:重试等待的时间间隔，默认为0。
interval_step:每次重试让重试间隔增加的秒数，默认为0.2秒。
interval_max:重试间隔最⼤的秒数，既通过interval_step增⼤到多少秒之后，就不在增加了，默认为0.2秒。
routing_key:⾃定义路由键queue：指定发送到哪个队列exchange：指定发送到哪个交换机priority：任务队列的优先级，0到255之间，对于rabbitmq来说0是最⾼优先级headers：为任务添加额外的消息还是使⽤前⾯的例⼦，使⽤task1和task2两个任务，demo.py调⽤在demo.py⾥更改调⽤⽅式from apps.task1 import addfrom apps.task2 import subsif__name__ == '__main__':add.delay(3,5)subs.apply_async(args=[55,22],task_id='aaaaa2222',countdown=5,shadow = 'zouzou')执⾏结果第三种app.send_task(task1.add,args=[1,2])不建议⽤，因为不会校验是否存在这个⽅法，直接就发送成功⾥，celery执⾏就会报错task参数task常⽤参数name：可以显⽰指定任务的名字，默认是本函数的名字，也就是上⾯的 shadowbind：⼀个bool值，设置是否绑定⼀个task的实例，如果绑定，task实例会作为参数传递到任务⽅法中（第⼀个参数为self），可以访问task实例的所有属性。
面试必问的celery，你了解多少？
⾯试必问的celery，你了解多少？celery是什么，有什么⽤？对于celery，各种⽂档解释⼀堆，可以⾃⼰看下，根据⽇常互动，公众号⽤户⼩⽩居多，官⽅⽤到的很多名词可能你理解起来不是那么容易，我这⾥就不照本宣科了，就以我这边的理解简单以下⽅图⽰解释下，如果有误，欢迎指正：⾸先理解⼀个概念：阻塞理解阻塞，先从耗时操作讲起，常见的场景⽐如⽤户输⼊、等待（sleep）这些都属于，具体到实际项⽬中⽐如说发邮件、发短信、机器/深度学习训练模型、⾃动化测试中的各种操作流程等待都会产⽣耗时，耗时操作通常我们也会称之为阻塞，意思就是程序⼀⾏⼀⾏代码执⾏，你这些耗时操作没执⾏完毕，后⾯的代码就不会执⾏，阻塞了后⾯的代码执⾏理解了阻塞以后，就很容易引出⼀个问题？我如果想提⾼程序执⾏效率不让程序阻塞，那该怎么办？有没有⼀种⽅式，能在程序阻塞的时候，不影响我后⾯代码的执⾏？⼀般来说，我们可以⽤线程、进程、协程，都是可以实现的，只不过在实际项⽬中，有成熟开源并且⼴泛应⽤的的东西，我们会⽤框架，⽽不去⼿写多线程、进程、协程，也不是说这些不⽤去学，这是编程的基本知识，也是必须掌握的，很能体现编程基本功底celery基本原理：1、客户端也就是python（django/flask等）发布任务2、发布的任务存到任务队列⾥⾯，可以以redis、rabbitMQ、MessageQueue、MySQL存储，⼀般在django/flask程序⾥redis居多3、任务处理者会不断从任务队列⾥⾯获取任务执⾏1、安装django/celery库django==2.0.6celery==3.1.26django-celery==3.3.0redis==2.10.6都⽤pip安装，我这边这⼏个版本测试没问题，版本有些时候不兼容，如果报错，⽹上找下解决2、redis数据库安装redis安装：/book/redis10/注意以下⼏点：1、redis.conf改bind127.0.0.1为bind 真实ip，这样可以远程访问2、如果是阿⾥云服务器，需要在控制台将6379端⼝开放3、redis启动服务端：redis-server,启动客户端：redis-cli3、演⽰代码demo整体流程是在前⾯页⾯点击表格⾥⾯的执⾏，会⽤selenium打开浏览器，执⾏耗时操作，相当于每个执⾏都是⼀个单独耗时任务4、demo前端代码：给按钮绑定run_case2⽅法，获取当前表格⾏号（映射要⽤selenium打开的⽹站链接），作为参数传到后端function run_case2(obj){row_tr = obj.parentNode.parentNode.rowIndex;//获取当前⾏数console.log(row_tr);param = {"url":row_tr};$.post('/web/yzm/', param, function (data) {console.log(data.result)})}5、demo后端代码：（阻塞写法）看下⾯代码，前端传的⾏号，我这只是为了测试传参数，随便构造的，分别跟3个⽹址进⾏映射，对于下⾯的这种写法，就是典型的阻塞线程，webdriver在执⾏的时候，只有当把quit()关闭浏览器执⾏完毕时候，才会return返回结果并在控制台打印success，如下图演⽰，我点击的是第三个执⾏按钮from selenium import webdriverimport time@csrf_exempt@login_requireddef yzm(request):url_num = request.POST.get("url")if int(url_num)==1:url_str = "https://"elif int(url_num==2:url_str = ""elif int(url_num)==3:url_str = ""print(url_num,url_str)# 下⾯webdriver打开⽹站，并休眠5秒钟都是耗时任务driver = webdriver.Chrome(executable_path="C:chromedriver_win32chromedriver.exe")driver.get(url_str)time.sleep(5)driver.quit()# 耗时任务执⾏完毕开始returnreturn JsonResponse({"result": "success"})6、demo后端代码：（celery异步）异步：名字虽然为异步，你可以理解为同步，就是⼀边做耗时操作，⼀般执⾏后⾯代码，两者同时执⾏⽂件⽬录，我在项⽬⽬录下⾯建⽴了celery_task包，创建tasks.py⽂件1、创建app,代表⼀个celery对象，broker代表队列，⽤的redis 0号数据库2、然后将上⼀步我们selenium打开浏览器的⽅法封装成open_url⽅法3、@app.task代表定义任务，指明这个open_url⽅法是⼀个任务，可以在视图⾥⾯调⽤发布from celery import Celeryfrom selenium import webdriverimport time# 创建celery的应⽤app = Celery("celery_task", broker="redis://47.101.203.45:6379/0")@app.taskdef open_url(url):driver = webdriver.Chrome(executable_path="C:chromedriver_win32chromedriver.exe")driver.get(url)time.sleep(5)driver.quit()views.py视图⾥⾯这样写1、from celery_task.tasks import open_url为导⼊任务2、open_url.delay(url_str)为发布任务,其中delay⾥⾯可以传参数，你前端传过来的参数views.py视图函数接收，可以再传到celery任务中去效果图如下：当点击执⾏时候，return的success很快就返回并打印了，跟我操控浏览器的过程没⼀点牵涉，⽆需等待selenium，这样就实现了⾮阻塞异步，完美解决了耗时问题from celery_task.tasks import open_url@csrf_exempt@login_requireddef yzm2(request):url_num = request.POST.get("url")if int(url_num)==1:url_str = "https://"elif int(url_num)==2:url_str = ""elif int(url_num)==3:url_str = ""print(url_num,url_str)open_url.delay(url_str)return JsonResponse({"result":"success"})7、多个任务同时执⾏对于多个任务同时执⾏，我这⾥连续点击三个执⾏按钮，⽴马先打印了3个success，说明3个任务都被celery异步处理了，对于多任务的参数问题，上⾯也说了，我们在delay⾥⾯传⼊参数即可，传到定义任务的tasks.py⽂件⾥⾯的对于⽅法中去，本例中我演⽰的是传了⼀个url_str参数8、启动程序打开两个终端，都切换到项⽬⽬录下⾯1、先启动celery：celery -A celery_task.tasks worker -l info2、再启动django：python manage.py runserver本⽂重要的是理解原理，celery的⽜逼远不⽌于此，有兴趣可以看看在爬⾍、机器学习、深度学习领域的使⽤，会对celery的使⽤场景有更清晰的认识。
celery设置并发数的原理
celery设置并发数的原理Celery是一个使用Python编写的分布式任务队列，它可以帮助开发者以异步的方式处理大量的任务。
在使用Celery时，我们经常需要设置并发数来控制同时处理任务的数量。
本文将介绍Celery设置并发数的原理以及相关的注意事项。
一、为什么需要设置并发数在实际的应用场景中，可能会遇到需要同时处理大量任务的情况。
如果不进行并发控制，所有的任务都会同时被执行，可能会导致系统资源过度占用，甚至引发系统崩溃。
因此，设置并发数可以有效地控制任务的执行数量，避免系统资源被过度消耗。
二、Celery的并发数设置原理Celery的并发数是通过设置worker进程数量来实现的。
worker进程是Celery的执行单元，每个worker进程都可以同时处理一个任务。
通过设置并发数，我们可以控制同一时间内同时执行的worker 进程数量，从而控制任务的并发度。
在Celery中，可以通过以下方式设置并发数：1. 在启动worker进程时，通过命令行参数-c或--concurrency设置并发数。
例如，celery worker -c 4表示启动4个worker进程，即并发数为4。
2. 在配置文件中设置并发数。
通过修改配置文件中的worker_concurrency参数，可以指定并发数的数值。
无论是通过命令行参数还是配置文件，设置的并发数都会应用于所有的worker进程。
三、并发数的注意事项在设置并发数时，需要注意以下几点：1. 硬件资源限制：并发数的设置应该根据系统的硬件资源来确定。
如果系统的CPU、内存等资源有限，设置过高的并发数可能会导致系统负载过高。
因此，需要根据实际情况进行调整，避免资源过度占用。
2. 任务类型：不同类型的任务对系统资源的消耗是不同的。
一些任务可能需要更多的CPU或内存资源，而另一些任务可能是IO密集型的。
在设置并发数时，需要考虑任务的特点，合理分配系统资源。
3. 网络延迟：如果任务涉及网络请求，网络延迟可能会对并发数产生影响。
celery定时任务原理
celery定时任务原理Celery是一个基于Python开发的分布式任务调度框架，它可以让我们轻松地实现定时任务。
下面将从Celery的原理和使用方法两个方面来探讨Celery定时任务的原理。
一、Celery的原理1. 分布式消息传递：Celery使用消息队列作为任务消息的传递方式。
当我们需要执行一个定时任务时，首先将任务消息发送给消息队列，然后由Celery的Worker去监听消息队列，一旦有任务消息进入队列，Worker就会将其取出并执行。
2. 任务调度器：Celery的任务调度器负责根据设定的时间规则来触发任务的执行。
它会根据设定的时间间隔或具体的时间点来生成任务消息，并发送给消息队列。
3. Worker进程：Worker进程是Celery的执行者，它负责监听消息队列，接收任务消息并执行相应的任务。
一个Celery应用可以启动多个Worker进程，以便并行地执行任务。
二、Celery定时任务的使用方法1. 安装Celery：首先需要安装Celery库，可以使用pip命令进行安装：pip install celery。
2. 配置Celery：在项目中创建一个celery.py文件，用于配置Celery的相关参数，如消息队列的地址、任务结果的存储方式等。
在配置文件中，我们需要指定消息队列的地址，例如使用RabbitMQ 作为消息队列，可以配置如下：```pythonfrom celery import Celeryapp = Celery('myapp', broker='pyamqp://guest@localhost//')```3. 创建任务：在项目中创建tasks.py文件，用于定义具体的任务。
每个任务都是一个函数，可以在函数上方使用@app.task装饰器进行标记。
例如，我们定义一个发送邮件的任务如下：```pythonfrom celery import Celeryapp = Celery('myapp', broker='pyamqp://guest@localhost//')@app.taskdef send_email(to, subject, content):# 发送邮件的具体逻辑pass```4. 设定定时规则：在项目中创建一个定时任务配置文件，例如celerybeat_schedule.py，用于设定定时任务的执行规则。
celery定时任务原理
celery定时任务原理Celery定时任务原理一、引言在现代的软件开发中，经常会遇到需要定时执行某些任务的需求。
比如，每天凌晨执行数据备份任务，每小时发送一次报告，或者每隔一段时间清理一次缓存等。
为了实现这些定时任务，我们需要一种可靠的机制来管理任务的调度和执行。
二、什么是CeleryCelery是一种基于Python的分布式任务队列系统，用于处理大量的异步任务。
它提供了简单易用的方式来实现任务的调度和执行，并支持各种任务类型，如定时任务、延迟任务、循环任务等。
Celery使用消息中间件作为任务调度的核心，通过消息队列来传递任务和结果，从而实现任务的分发和执行。
三、Celery的架构Celery的架构包括以下几个核心组件：1. 任务发布者（Task Publisher）：负责将任务发布到消息队列中，让工人进程来执行。
2. 消息队列（Message Broker）：用于存储任务消息，通常使用RabbitMQ、Redis等作为消息中间件。
3. 工人进程（Worker Process）：实际执行任务的进程，从消息队列中获取任务消息，并执行相应的任务逻辑。
4. 结果存储（Result Backend）：用于存储任务执行的结果，通常使用数据库或缓存系统。
四、Celery定时任务原理在Celery中，定时任务是通过调度器（Scheduler）来管理的。
调度器负责按照预定的时间表执行任务，它会根据任务的设定时间来生成对应的消息，并将消息发布到消息队列中。
工人进程会从消息队列中获取任务消息，并根据消息中的任务信息执行相应的逻辑。
1. 设定任务的调度时间在Celery中，我们可以使用crontab表达式来设定任务的调度时间。
crontab表达式是一种时间表达式，用于指定任务应该在何时执行。
它由五个字段组成，分别表示分钟、小时、日期、月份和星期几。
例如，'0 0 * * *'表示每天凌晨执行任务。
PythonCelery异步任务队列使用方法解析
PythonCelery异步任务队列使⽤⽅法解析Celery是⼀个异步的任务队列(也叫做分布式任务队列),⼀个简单，灵活，可靠的分布式系统，⽤于处理⼤量消息，同时为操作提供维护此类系统所需要的⼯具。
celery的优点1:简单，容易使⽤，不需要配置⽂件2:⾼可⽤，任务执⾏失败或执⾏过程中发⽣连续中断，celery会⾃动尝试重新执⾏任务3:快速，⼀个单进程的celery每分钟可以处理上百万个任务4:灵活，⼏乎celery的各个组件都可以被扩展celery应⽤场景1:异步发邮件，⼀般发邮件等⽐较耗时的操作，这个时候需要提交任务给celery就可以了，由worker进⾏发邮件操作2:有些跑批量接⼝任务，需要耗时较长，也可以做成异步任务3:定时调度任务Celery与Django⼀起使⽤(以发送短信为例)独⽴于项⽬新建⼀个package包在package包中新建⼀个名为sms的package包新建tasks.py⽂件#定义耗时的函数from utils.ytx_sdk.sendSMS import CCPfrom celery_tasks.main import app#为函数添加装饰器，这个函数就成为了celery的任务@app.taskdef send_sms_code(mobile,code,expires,template_id):try:# CCP.sendTemplateSMS(mobile,code,expires,template_id)print(code)except:return '发送短信失败'在package包中新建config.py内容如下(中间⼈，接收⽣产者发来的消息即Task，将任务存⼊队列。
任务的消费者是Worker。
Celery本⾝不提供队列服务，推荐⽤Redis或RabbitMQ实现队列服务。
)#指定代理⼈队列==>redisbroker_url='redis://127.0.0.1:6379/15'在package包中新建main.py内容如下(需要将task注册到celery应⽤中)#启动⼯⼈的⽂件from celery import Celery# 为celery使⽤django配置⽂件进⾏设置import osif not os.getenv('DJANGO_SETTINGS_MODULE'):os.environ['DJANGO_SETTINGS_MODULE'] = 'yinyue.settings.dev'# 创建celery应⽤app = Celery('yinyue')# 导⼊celery配置app.config_from_object('celery_tasks.config')# ⾃动注册celery任务app.autodiscover_tasks(['celery_tasks.sms'])在django框架对应模块的视图中使⽤#调⽤celery的任务：任务名.delay(参数)send_sms_code.delay(mobile,code,constants.SMS_CODE_EXPIRES/60,1)启动celery服务: celery -A celery_tasks.main worker -l info以上就是本⽂的全部内容，希望对⼤家的学习有所帮助，也希望⼤家多多⽀持。
celery beat 原理
Celery是一个分布式任务队列系统，而Celery Beat是Celery的一个组件，用于处理定时任务调度。
Celery Beat负责周期性地触发Celery任务，使其按照预定的时间执行。
以下是Celery Beat的基本原理：1. 配置定时任务：用户通过配置文件或代码指定需要定时执行的任务。
这些任务通常是Celery任务，即异步执行的函数或方法。
2. 调度器：Celery Beat包含一个调度器，负责根据配置的时间表计划任务的执行。
时间表可以使用类似Cron的表达式或者简单的时间间隔来定义。
3. 任务队列：Celery Beat将计划的任务发送到Celery任务队列。
Celery任务队列由Celery Worker处理，负责执行队列中的任务。
4. 分布式执行：如果系统中有多个Celery Worker节点，Celery Beat将任务分发到这些节点上执行。
这使得Celery系统具有横向扩展性，可以处理大量的任务和负载。
5. 结果存储：对于定时任务，可能需要存储执行结果或者错误信息。
Celery支持结果存储，可以将任务执行的结果保存在诸如数据库、缓存系统或者其他后端存储中。
6. 错误处理：Celery Beat能够处理任务执行过程中的错误，可以配置重试策略和错误处理逻辑，确保任务能够尽可能地完成。
7. 周期性任务的持久性：Celery Beat支持持久性，即使在系统重启后也能够保持已计划的周期性任务。
这是通过将任务计划信息存储在持久性存储中实现的，比如数据库。
总体来说，Celery Beat通过调度器、任务队列和分布式执行的方式，实现了对定时任务的高效调度和执行。
这使得开发人员能够方便地在分布式环境中管理和执行定时任务，提高了系统的可扩展性和灵活性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
topic类型与direct类型很相似，主要是扩展了模糊匹配，它约定：
➢binding key与routing key均可设置为以“.”相连的字符串，例如： “quick.orange.rabbit”，每个以“.”分隔开的字符串视作一个“单 词”，比如上例的单词为“quick”、“orange”、“rabbit”
保证消息的可靠传递。如果发送消息时接收者不可用，消息 队列会保留消息，直到成功地传递它；
提供异步的通信协议。消息的发送者将消息发送到消息队列 后可以立即返回，不用等待接收者的响应，消息会被保存在 队列中，直到接收者取出它；
03
即Advanced Message Queuing Protocol,一个提供统一消息服务的应用层标 准高级消息队列协议,是应用层协议的一个开放标准,为面向消息的中间件设 计。基于此协议的客户端与消息中间件可传递消息，并不受客户端/中间件不 同产品，不同开发语言等条件的限制。
因为队列只允许在后端插入，在前端移除，所以只有最早进 入队列的元素才能最先从队列中移除，故队列又称为先进先 出（FIFO—first in first out）线性表。
02
消息队列中的“消息”即指同一台计算机的进程间，或不同 计算机的进程间传送的数据；
“消息队列”即指的是在消息的传输过程中保存消息的“队 列”。
Broker Settings ➢CELERY_ACCEPT_CONTENT ➢BROKER_URL ➢BROKER_CONNECTION_TIMEOUT ➢BROKER_CONNECTION_RETRY ➢BROKER_CONNECTION_MAX_RETRIES
Worker Settings ➢CELERY_IMPORTS
rabbitMQ是一个使用Erlang语言编写的，完整实现AMQP的服 务端，支持多种语言的client进行访问。
Redis是一个可内存亦可持久化的日志型、Key-Value数据库。 由于其支持list类型的数据，以及支持push/pop操作的特性， 使其在很多领域被用作了高速队列来使用。
rabbitMQ一般用于企业级环境，比较庞大（约90MB左右）， 另外还必须先安装Erlang才能用。
➢binding key中可以存在两种特殊字符“*”与“#”，用于做模糊匹配， 其中“*”用于匹配一个单词，“#”用于匹配多个单词（可以是零个）
➢当消息的routing key与某个Queue绑定的binding key匹配时，则可路由 到该Queue
fanout类型最简单，这种类型会无视binding key，将消息路由到每个与之 绑定的Queue：
Redis比较小巧（0.5MB），功能完备性比不上rabbitMQ，但 经过Celery的一番构造，使其也具备了AMQP模型的各种功能， 已能胜任绝大部分应用场景。
推荐使用Redis
Celery的依赖库极其多（虽然大部分是可选的），因此推荐 使用pip安装
pip install -U celery[redis]==3.1.19
Consumer端：Celery中的Consumer，称之为“Worker”。其 除了订阅并处理任务外，还附加一些丰富的配置和管理功能。
Backend端：用于保存任务执行的结果（可选组件）。
官方推荐rabbitMQ及Redis两种Broker方案，其他Broker方 案均只是作为实验性质的，不推荐用在Deployment环境。
01 队列（Queue） 消息队列（MQ）
02
03 高级消息队列协议 （AMQP） Ｃｅｌｅｒｙ的使用
04
01
队列是一种特殊的线性表，特殊之处在于它只允许在表的前 端（front）进行移除操作，而在表的后端（rear）进行插 入操作。
队列的数据元素又称为队列元素。在队列中插入一个队列元 素称为入队，从队列中移除一个队列元素成为出队。
消息队列的产品及协议标准不一致，使应用与消息队列之间 的耦合加大。
各种消息队列的开发都基于各自的开发语言，使用上受限。
生产者
消费者
如果每个消息的处理时间不同，就有可能会导致某些Consumer一直在忙，而 另外一些Consumer很快就处理完手头工作并一直空闲的情况
这种情况下，可以限制Queue每次给每个Consumer只发送一条消息；某个 Consumer处理完这条消息后Queue再给该Consumer发送一条消息。
0４
Celery是一个处理大量消息的分布式系统，并且提供维护这 样一个系统的必需工具。
专注于实时处理的任务队列，同时也支持任务调度。
Producer端：只要某个任务（函数）是Celery实例的task方 法修饰过的，调用时就会自动投）：Celery本身并不提供MQ服务，因 此Celery需要一个MQ的解决方案，其通常以独立服务形式出 现，称为“Broker”。
另外需要单独安装Redis服务端（独立运行软件，非Python 包），Windows和Linux需要分别下载。
在上述的演示实例中，有很多细节是没有涉及到的，比如： Celery构建了几个Queue？Worker怎么订阅到这些Queue上的？ Queue是按轮询分发还是公平分发？
如上提及的这些配置，在使用Celery时实际都是需要明确的， 但是上述的演示实例中却几乎没有配置过，这是因为Celery 本身有一套默认配置，能胜任大部分的使用环境（虽然效率 可能不是最优的）
➢CELERY_INCLUDE
➢CELERYD_TASK_TIME_LIMIT
Message Routing ➢CELERY_QUEUES ➢CELERY_ROUTES ➢CELERY_CREATE_MISSING_QUEUES ➢CELERY_DEFAULT_QUEUE ➢CELERY_DEFAULT_EXCHANGE ➢CELERY_DEFAULT_EXCHANGE_TYPE ➢CELERY_DEFAULT_ROUTING_KEY