Celery 核心概念详解及示例

Celery 是一个简单、灵活且可靠的分布式系统，用于处理大量消息，提供对任务队列的操作，并支持任务的调度和异步执行。它常用于深度优化 Web 应用的性能和响应速度，通过将耗时的操作移到后台异步执行，使主程序不被阻塞。

本文将统一介绍 Celery 中的核心概念，并通过示例进行说明，帮助您深入理解并应用 Celery 来构建高性能的异步任务处理系统。

[Celery 核心概念详解及示例](#Celery 核心概念详解及示例)
- 任务（Task）
- - 示例
- 工作者（Worker）
- - [启动 Worker](#启动 Worker)
- 消息代理（Broker）
- - 配置示例
- 客户端（Client）
- - 任务调用示例
- [结果后端（Result Backend）](#结果后端（Result Backend）)
- - 配置示例
  - 获取任务结果
- 任务队列（Queue）
- - 定义队列中的任务
  - [启动 Worker 监听指定队列](#启动 Worker 监听指定队列)
- [任务路由（Task Routing）](#任务路由（Task Routing）)
- - 配置路由
- 并发（Concurrency）
- - [启动 Worker 指定并发方式](#启动 Worker 指定并发方式)
- [定时任务（Periodic Tasks）](#定时任务（Periodic Tasks）)
- - 配置定时任务
  - [启动 Celery Beat](#启动 Celery Beat)
- [任务重试与超时（Task Retry and Timeout）](#任务重试与超时（Task Retry and Timeout）)
- - 设置任务重试
  - 设置任务超时
- [任务组与工作流（Task Groups and Workflows）](#任务组与工作流（Task Groups and Workflows）)
- - 组任务（Group）
  - 链任务（Chain）
- 示例项目结构
- - tasks.py
  - app.py
  - worker.sh
- 总结
- 参考资料

任务（Task）

任务（Task） 是 Celery 的基本执行单元，表示要执行的具体函数或操作。在 Celery 中，任务通常由装饰器 @task 或 @shared_task 声明。

示例

python 复制代码

# tasks.py
from celery import Celery

app = Celery('tasks', broker='redis://localhost:6379/0')

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

说明：
- 使用 @app.task 装饰器将函数 add 声明为一个 Celery 任务。
- 任务可以被工作者执行，并可以异步调用。

工作者（Worker）

工作者（Worker） 是实际执行任务的进程或节点。工作者从消息代理中获取任务，执行任务函数，并返回结果。

启动 Worker

bash 复制代码

celery -A tasks worker --loglevel=INFO

说明：
- -A tasks：指定 Celery 应用实例的位置。
- worker：启动一个工作者进程。
- --loglevel=INFO：设置日志级别。

消息代理（Broker）

消息代理（Broker） 是任务队列的中介，负责接收来自客户端的任务，并将任务分发给工作者。常用的消息代理包括 Redis 、RabbitMQ 、Amazon SQS 等。

配置示例

python 复制代码

# 使用 Redis 作为消息代理
app = Celery('tasks', broker='redis://localhost:6379/0')

说明：
- broker 参数指定消息代理的连接 URL。

客户端（Client）

客户端（Client） 是发送任务到消息代理的应用程序。它可以是 Web 应用、脚本等，使用 Celery 的 API 将任务异步地发送到 Broker。

任务调用示例

python 复制代码

# 调用加法任务
from tasks import add

result = add.delay(4, 6)

说明：
- 使用 delay() 方法将任务发送到消息代理，立即返回一个 AsyncResult 对象。
- 任务将在后台执行，客户端无需等待任务完成。

结果后端（Result Backend）

结果后端（Result Backend） 用于存储任务执行的结果，允许客户端在任务执行完成后获取结果。常用的结果后端包括 Redis 、RabbitMQ 、数据库 等。

配置示例

python 复制代码

# 使用 Redis 作为结果后端
app = Celery('tasks', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0')

获取任务结果

python 复制代码

# 获取任务结果
result = add.delay(4, 6)
print(result.get(timeout=10))  # 输出 10

说明：
- result.get(timeout=10)：等待任务完成并获取结果，超时设置为 10 秒。

任务队列（Queue）

任务队列（Queue） 是存储任务的队列，允许将任务分类、路由和分配。队列的使用可以实现任务的隔离和资源的优化。

定义队列中的任务

python 复制代码

@app.task(queue='priority_high')
def high_priority_task():
    pass

启动 Worker 监听指定队列

bash 复制代码

celery -A tasks worker -Q priority_high --loglevel=INFO

说明：
- -Q priority_high：指定 Worker 只监听名为 priority_high 的队列。

任务路由（Task Routing）

任务路由（Task Routing） 用于将任务分配到特定的队列，可以在任务定义、配置文件或运行时指定。

配置路由

python 复制代码

# 配置路由规则
app.conf.task_routes = {
    'tasks.add': {'queue': 'math_queue'},
    'tasks.mul': {'queue': 'math_queue'},
    'tasks.email': {'queue': 'email_queue'},
}

说明：
- 将 add 和 mul 任务路由到 math_queue 队列，email 任务路由到 email_queue 队列。

并发（Concurrency）

Celery 支持多种并发方式，包括多进程、多线程和协程。常用的并发池有 prefork （默认，多进程）、eventlet （协程）、gevent（协程）。

启动 Worker 指定并发方式

bash 复制代码

# 使用多进程并发，设置并发数为 4
celery -A tasks worker --concurrency=4

# 使用 gevent 并发
celery -A tasks worker -P gevent --concurrency=1000

说明：
- --concurrency=4：设置并发的工作进程数。
- -P gevent：指定并发池为 gevent，适用于 I/O 密集型任务。

定时任务（Periodic Tasks）

定时任务（Periodic Tasks） 是指按照预设的时间间隔或特定时间点自动执行的任务。Celery 提供了 Celery Beat 调度器来管理定时任务。

配置定时任务

python 复制代码

from celery.schedules import crontab

app.conf.beat_schedule = {
    'add-every-30-seconds': {
        'task': 'tasks.add',
        'schedule': 30.0,
        'args': (16, 16)
    },
    'multiply-at-midnight': {
        'task': 'tasks.mul',
        'schedule': crontab(hour=0, minute=0),
        'args': (4, 5),
    },
}

启动 Celery Beat

bash 复制代码

celery -A tasks beat --loglevel=INFO

说明：
- Celery Beat 会按照配置的计划周期性地发送任务到 Broker。

任务重试与超时（Task Retry and Timeout）

任务在执行过程中可能失败，Celery 提供了任务重试和超时机制，增强任务的可靠性。

设置任务重试

python 复制代码

@app.task(bind=True, max_retries=3, default_retry_delay=60)
def unstable_task(self, *args):
    try:
        # 可能出现异常的代码
        pass
    except Exception as exc:
        # 任务失败后重试
        raise self.retry(exc=exc)

说明：
- max_retries=3：最大重试次数为 3 次。
- default_retry_delay=60：每次重试之间的间隔为 60 秒。
- self.retry(exc=exc)：任务失败时抛出 retry 异常，实现重试。

设置任务超时

python 复制代码

@app.task(time_limit=300, soft_time_limit=200)
def long_running_task():
    pass

说明：
- time_limit=300：任务的硬超时时间为 300 秒，超时后工作进程会被杀死。
- soft_time_limit=200：任务的软超时时间为 200 秒，超时后会抛出 SoftTimeLimitExceeded 异常，可以在任务中捕获并处理。

任务组与工作流（Task Groups and Workflows）

Celery 支持任务的组合执行，包括组任务（Group Tasks） 、链任务（Chain Tasks） 和 回调（Callbacks），用于构建复杂的工作流。

组任务（Group）

同时执行一组独立的任务，所有任务完成后返回结果列表。

python 复制代码

from celery import group

# 定义任务组
job = group(add.s(i, i) for i in range(10))
result = job.apply_async()

# 获取所有任务的结果
print(result.get())

说明：
- add.s(i, i)：生成任务的签名。
- group()：创建任务组。
- apply_async()：异步执行任务组。

链任务（Chain）

顺序执行一系列任务，每个任务的结果作为下一个任务的输入。

python 复制代码

from celery import chain

# 定义任务链
job = chain(add.s(2, 2) | mul.s(4))

result = job.apply_async()

# 获取最终结果
print(result.get())  # 输出 (2 + 2) * 4 = 16

说明：
- | 运算符连接任务，表示顺序执行。

示例项目结构

一个简单的 Celery 项目通常包含以下结构：

复制代码

project/
│
├── tasks.py          # 定义任务
├── app.py            # 定义 Celery 应用
└── worker.sh         # 启动 Worker 的脚本

tasks.py

python 复制代码

from app import app

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

@app.task
def mul(x, y):
    return x * y

app.py

python 复制代码

from celery import Celery

app = Celery('project',
             broker='redis://localhost:6379/0',
             backend='redis://localhost:6379/0')

# 可在此处配置任务路由、定时任务等

worker.sh

bash 复制代码

#!/bin/bash
celery -A app worker --loglevel=INFO

总结

Celery 通过引入任务、工作者 、消息代理 、结果后端 、任务队列 等核心概念，构建了一个强大的异步任务处理框架。通过合理地配置和使用这些概念，您可以：

异步执行耗时任务，提高应用程序的响应速度。
实现任务的调度和重试，增强系统的可靠性。
优化资源利用率，通过并发和队列管理提升性能。
构建复杂的任务工作流，满足多样化的业务需求。

希望通过本文对 Celery 核心概念的统一介绍和示例说明，您可以更好地理解和应用 Celery，在实际项目中构建高性能的异步任务处理系统。

Celery 核心概念详解及示例